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
feat(auth_service): macro authorization (#4967)
Will Hutchinson06474018e19b
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 98bfa88c46..6ca7983643 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -4324,6 +4324,7 @@"crates/ip_extractor","crates/last_online_tracker","crates/macro_auth",+ "crates/macro_authorization","crates/macro_env","crates/macro_env_var","crates/macro_service_urls",diff --git a/Cargo.lock b/Cargo.lockindex d9cebbe69b..3e27171a02 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -969,6 +969,7 @@ dependencies = ["cookie","cool_asserts","database_env_vars",+ "decode_jwt","document_storage_service_client","doppleganger","doppler-config",@@ -985,6 +986,7 @@ dependencies = ["last_online_tracker","loops_client","macro_auth",+ "macro_authorization","macro_aws_config","macro_cache_client","macro_config",@@ -1006,8 +1008,6 @@ dependencies = ["model","model-entity","model_notifications",- "model_user",- "models_team","native_app_service","non_empty","notification",@@ -11640,6 +11640,7 @@ dependencies = ["http-body-util","invite_email","ip_extractor",+ "macro_authorization","macro_db_migrator","macro_user_id","macro_uuid",@@ -14059,6 +14060,7 @@ dependencies = ["axum","chrono","entity_access",+ "macro_authorization","macro_db_migrator","macro_user_id","macro_uuid",@@ -14078,6 +14080,7 @@ dependencies = ["sqs_client","thiserror 2.0.18","tokio",+ "tower 0.5.3","tracing","url","utoipa",@@ -15476,6 +15479,7 @@ dependencies = ["futures","hex","hmac 0.12.1",+ "macro_authorization","macro_db_migrator","macro_env","macro_event_broker",diff --git a/crates/entity_access/src/inbound/axum_extractors/mod.rs b/crates/entity_access/src/inbound/axum_extractors/mod.rsindex 500e33ec19..648511b33e 100644--- a/crates/entity_access/src/inbound/axum_extractors/mod.rs+++ b/crates/entity_access/src/inbound/axum_extractors/mod.rs@@ -32,7 +32,8 @@ pub use project::{ProjectAccessLevelExtractor, ProjectBodyAccessLevelExtractor, ProjectBodyAccessLevelExtractorV2,};pub use team::{- MacroUserTeamExtractor, OptionalMacroUserTeamExtractor, OptionalMacroUserTeamExtractorV2,+ MacroUserTeamExtractor, MacroUserTeamExtractorV2, OptionalMacroUserTeamExtractor,+ OptionalMacroUserTeamExtractorV2,};pub use thread::ThreadAccessLevelExtractor;diff --git a/crates/entity_access/src/inbound/axum_extractors/team.rs b/crates/entity_access/src/inbound/axum_extractors/team.rsindex dbf833aba2..49a2ca391d 100644--- a/crates/entity_access/src/inbound/axum_extractors/team.rs+++ b/crates/entity_access/src/inbound/axum_extractors/team.rs@@ -40,6 +40,16 @@ impl<T: RequiredPermission> TeamAccessOutcome<T> {Self::NotInTeam | Self::InsufficientRole => None,}}++ fn into_required_receipt(self) -> Result<EntityAccessReceipt<T>, ExtractorError> {+ match self {+ Self::Qualifying(receipt) => Ok(receipt),+ Self::NotInTeam => Err(ExtractorError::UnauthorizedWithMessage("not in a team")),+ Self::InsufficientRole => Err(ExtractorError::UnauthorizedWithMessage(+ "you do not have a high enough role",+ )),+ }+ }}async fn team_access_outcome<T, Svc>(@@ -183,6 +193,48 @@ where}}+/// Authorizes a user and resolves their required team membership.+///+/// The extractor uses [`MacroAuthorizationExtractor`] to authenticate the request.+/// It returns an [`EntityAccessReceipt`] when the user belongs to a team and their+/// role satisfies `T`. A user without a team receives `"not in a team"`; a user+/// whose role does not satisfy `T` receives `"you do not have a high enough role"`.+#[derive(Debug)]+pub struct MacroUserTeamExtractorV2<T: RequiredPermission, Svc, Auth> {+ /// The entity access receipt for the authorized team member.+ pub entity_access_receipt: EntityAccessReceipt<T>,+ _marker: PhantomData<(T, Svc, Auth)>,+}++impl<T, S, Svc, Auth> FromRequestParts<S> for MacroUserTeamExtractorV2<T, Svc, Auth>+where+ T: RequiredPermission,+ Arc<Svc>: FromRef<S>,+ Svc: EntityAccessService,+ MacroAuthorizationState<Auth>: FromRef<S>,+ Auth: MacroAuthorizationService,+ S: Send + Sync + 'static,+{+ type Rejection = ExtractorError;++ #[tracing::instrument(err, skip(state, parts))]+ async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {+ let service = <Arc<Svc>>::from_ref(state);+ let MacroAuthorizationExtractor { macro_user_id, .. } = parts+ .extract_with_state(state)+ .await+ .map_err(ExtractorError::from)?;+ let entity_access_receipt = team_access_outcome::<T, Svc>(service.as_ref(), macro_user_id)+ .await?+ .into_required_receipt()?;++ Ok(Self {+ entity_access_receipt,+ _marker: PhantomData,+ })+ }+}+/// Resolves the authenticated user's team membership and exposes the receipt/// when the user satisfies the required permission `T`./// Returns `ExtractorError::Unauthorized` if there is no authenticated user or no team.@@ -211,18 +263,9 @@ where.await.map_err(|_| ExtractorError::Unauthorized)?;- let entity_access_receipt =- match team_access_outcome::<T, Svc>(service.as_ref(), macro_user_id).await? {- TeamAccessOutcome::Qualifying(receipt) => receipt,- TeamAccessOutcome::NotInTeam => {- return Err(ExtractorError::UnauthorizedWithMessage("not in a team"));- }- TeamAccessOutcome::InsufficientRole => {- return Err(ExtractorError::UnauthorizedWithMessage(- "you do not have a high enough role",- ));- }- };+ let entity_access_receipt = team_access_outcome::<T, Svc>(service.as_ref(), macro_user_id)+ .await?+ .into_required_receipt()?;Ok(Self {entity_access_receipt,diff --git a/crates/entity_access/src/inbound/axum_extractors/team/test.rs b/crates/entity_access/src/inbound/axum_extractors/team/test.rsindex 92586a3df5..00cac03bfc 100644--- a/crates/entity_access/src/inbound/axum_extractors/team/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/team/test.rs@@ -37,6 +37,8 @@ type V2Extractor = OptionalMacroUserTeamExtractorV2<FakeEntityAccessService,FakeAuthorizationService,>;+type RequiredV2Extractor =+ MacroUserTeamExtractorV2<AdminTeamRole, FakeEntityAccessService, FakeAuthorizationService>;type V1RequiredExtractor = MacroUserTeamExtractor<AdminTeamRole, FakeEntityAccessService>;#[derive(Clone, Debug, Default)]@@ -247,6 +249,14 @@ async fn extract_v2(V2Extractor::from_request_parts(&mut parts, state).await}+async fn extract_required_v2(+ request: Request<Body>,+ state: &TestState,+) -> Result<RequiredV2Extractor, ExtractorError> {+ let (mut parts, _) = request.into_parts();+ RequiredV2Extractor::from_request_parts(&mut parts, state).await+}+async fn extract_v1_required(mut request: Request<Body>,state: &TestState,@@ -278,6 +288,129 @@ fn assert_receipt(receipt: &EntityAccessReceipt<AdminTeamRole>, user_id: &str, r));}+#[tokio::test]+async fn required_v2_accepts_bearer_credentials_for_a_qualifying_member() {+ let state = state(+ FakeEntityAccessService::default().with_membership(USER_ID, TeamRole::Admin),+ FakeAuthorizationService::default(),+ );++ let extracted = extract_required_v2(bearer_request("valid"), &state)+ .await+ .expect("qualifying bearer-authenticated membership should extract");++ assert_receipt(&extracted.entity_access_receipt, USER_ID, TeamRole::Admin);+}++#[tokio::test]+async fn required_v2_accepts_internal_acting_user_credentials() {+ let state = state(+ FakeEntityAccessService::default().with_membership(ACT_AS_USER_ID, TeamRole::Owner),+ FakeAuthorizationService::default(),+ );+ let request = Request::builder()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .header(INTERNAL_MACRO_USER_ID_HEADER, ACT_AS_USER_ID)+ .body(Body::empty())+ .expect("request should be valid");++ let extracted = extract_required_v2(request, &state)+ .await+ .expect("qualifying internal acting-user membership should extract");++ assert_receipt(+ &extracted.entity_access_receipt,+ ACT_AS_USER_ID,+ TeamRole::Owner,+ );+}++#[tokio::test]+async fn required_v2_rejects_missing_credentials() {+ let state = state(+ FakeEntityAccessService::default(),+ FakeAuthorizationService::default(),+ );++ let error = extract_required_v2(request(), &state)+ .await+ .expect_err("required authorization should reject missing credentials");+ let (status, body) = response_parts(error.into_response()).await;++ assert_eq!(status, StatusCode::UNAUTHORIZED);+ assert_eq!(body, r#"{"message":"unauthorized"}"#);+}++#[tokio::test]+async fn required_v2_rejects_expired_credentials() {+ let state = state(+ FakeEntityAccessService::default(),+ FakeAuthorizationService::default(),+ );++ let error = extract_required_v2(bearer_request("expired"), &state)+ .await+ .expect_err("expired credentials should be rejected");+ let (status, body) = response_parts(error.into_response()).await;++ assert_eq!(status, StatusCode::UNAUTHORIZED);+ assert_eq!(body, r#"{"message":"jwt expired"}"#);+}++#[tokio::test]+async fn required_v2_preserves_no_membership_error() {+ let state = state(+ FakeEntityAccessService::default(),+ FakeAuthorizationService::default(),+ );++ let error = extract_required_v2(bearer_request("valid"), &state)+ .await+ .expect_err("required extraction should reject absent membership");++ assert!(matches!(+ error,+ ExtractorError::UnauthorizedWithMessage("not in a team")+ ));+}++#[tokio::test]+async fn required_v2_preserves_insufficient_role_error() {+ let state = state(+ FakeEntityAccessService::default().with_membership(USER_ID, TeamRole::Member),+ FakeAuthorizationService::default(),+ );++ let error = extract_required_v2(bearer_request("valid"), &state)+ .await+ .expect_err("required extraction should reject an insufficient role");++ assert!(matches!(+ error,+ ExtractorError::UnauthorizedWithMessage("you do not have a high enough role")+ ));+}++#[tokio::test]+async fn required_v2_rejects_identity_less_internal_credentials() {+ let state = state(+ FakeEntityAccessService::default(),+ FakeAuthorizationService::default(),+ );+ let request = Request::builder()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .body(Body::empty())+ .expect("request should be valid");++ let error = extract_required_v2(request, &state)+ .await+ .expect_err("required authorization should reject identity-less internal credentials");+ let (status, body) = response_parts(error.into_response()).await;++ assert_eq!(status, StatusCode::UNAUTHORIZED);+ assert_eq!(body, r#"{"message":"unauthorized"}"#);+}+#[tokio::test]async fn qualifying_roles_return_authenticated_team_receipts() {for role in [TeamRole::Admin, TeamRole::Owner] {diff --git a/crates/referral/Cargo.toml b/crates/referral/Cargo.tomlindex ac47e391c5..f5d5c2f638 100644--- a/crates/referral/Cargo.toml+++ b/crates/referral/Cargo.toml@@ -9,6 +9,7 @@ axum = ["dep:axum","dep:axum-extra","dep:ip_extractor",+ "dep:macro_authorization","dep:model-error-response","dep:model_user","dep:tower",@@ -31,6 +32,9 @@ tracing = { workspace = true }uuid = { workspace = true }# Domain models+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = [+ "axum",+] }macro_user_id = { path = "../macro_user_id" }macro_uuid = { path = "../macro_uuid" }model-entity = { path = "../model-entity" }diff --git a/crates/referral/src/inbound/axum_router.rs b/crates/referral/src/inbound/axum_router.rsindex b9d6be8751..4e7810b4ba 100644--- a/crates/referral/src/inbound/axum_router.rs+++ b/crates/referral/src/inbound/axum_router.rs@@ -5,11 +5,15 @@use crate::domain::models::ReferralError;use crate::domain::ports::ReferralService;-use axum::{Json, Router, http::StatusCode, response::IntoResponse};+use axum::{Json, Router, extract::FromRef, http::StatusCode, response::IntoResponse};pub use get_referral_code::{__path_get_referral_code_handler, get_referral_code_handler};+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;-use rate_limit::RateLimitService;use rate_limit::inbound::rate_limit_middleware;+use rate_limit::{+ RateLimitConfig, RateLimitKey, RateLimitResult, RateLimitService, domain::models::RateLimitOk,+};+use rootcause::Report;pub use send_invite::{__path_post_referral_invite_handler, PerIpReferralRateLimit, PerUserReferralRateLimit,SendInviteBody, post_referral_invite_handler,@@ -51,39 +55,96 @@ impl IntoResponse for ReferralError {}/// Router state containing the referral service.-pub struct ReferralRouterState<T, R> {+pub struct ReferralRouterState<T, R, Auth> {/// The referral service implementation.pub service: Arc<T>,- /// the rate limiter service implementation+ /// The rate limiter service implementation.pub rate_limiter: R,+ /// State for request authorization.+ pub authorization_state: MacroAuthorizationState<Auth>,}-impl<T, R: Clone> Clone for ReferralRouterState<T, R> {+impl<T, R: Clone, Auth> Clone for ReferralRouterState<T, R, Auth> {fn clone(&self) -> Self {Self {service: self.service.clone(),rate_limiter: self.rate_limiter.clone(),+ authorization_state: self.authorization_state.clone(),+ }+ }+}++impl<T, R, Auth> FromRef<ReferralRouterState<T, R, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &ReferralRouterState<T, R, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++struct ReferralRateLimitState<R, Auth> {+ rate_limiter: R,+ authorization_state: MacroAuthorizationState<Auth>,+}++impl<R: Clone, Auth> Clone for ReferralRateLimitState<R, Auth> {+ fn clone(&self) -> Self {+ Self {+ rate_limiter: self.rate_limiter.clone(),+ authorization_state: self.authorization_state.clone(),}}}+impl<R, Auth> FromRef<ReferralRateLimitState<R, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &ReferralRateLimitState<R, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++impl<R, Auth> RateLimitService for ReferralRateLimitState<R, Auth>+where+ R: RateLimitService,+ Auth: MacroAuthorizationService,+{+ async fn check_rate_limit(+ &self,+ key: RateLimitKey,+ config: RateLimitConfig,+ ) -> Result<RateLimitResult, Report> {+ self.rate_limiter.check_rate_limit(key, config).await+ }++ async fn rollback_ticket(&self, ticket: RateLimitOk) -> Result<(), Report> {+ self.rate_limiter.rollback_ticket(ticket).await+ }+}+/// Build the referral router with all endpoints.-pub fn referral_router<T, S, R>(state: ReferralRouterState<T, R>) -> Router<S>+pub fn referral_router<T, S, R, Auth>(state: ReferralRouterState<T, R, Auth>) -> Router<S>whereT: ReferralService,R: RateLimitService + Clone,+ Auth: MacroAuthorizationService,S: Send + Sync + 'static,{+ let user_rate_limit_state = ReferralRateLimitState {+ rate_limiter: state.rate_limiter.clone(),+ authorization_state: state.authorization_state.clone(),+ };+Router::new().route("/send",- axum::routing::post(post_referral_invite_handler::<T, R>),+ axum::routing::post(post_referral_invite_handler::<T, R, Auth>),).layer(ServiceBuilder::new().layer(axum::middleware::from_fn_with_state(- state.rate_limiter.clone(),- rate_limit_middleware::<R, PerUserReferralRateLimit, R>,+ user_rate_limit_state,+ rate_limit_middleware::<+ ReferralRateLimitState<R, Auth>,+ PerUserReferralRateLimit<Auth>,+ ReferralRateLimitState<R, Auth>,+ >,)).layer(axum::middleware::from_fn_with_state(state.rate_limiter.clone(),@@ -92,7 +153,7 @@ where).route("/code",- axum::routing::get(get_referral_code_handler::<T, R>),+ axum::routing::get(get_referral_code_handler::<T, R, Auth>),).with_state(state)}diff --git a/crates/referral/src/inbound/axum_router/get_referral_code.rs b/crates/referral/src/inbound/axum_router/get_referral_code.rsindex add721ad0d..aa19f6b81b 100644--- a/crates/referral/src/inbound/axum_router/get_referral_code.rs+++ b/crates/referral/src/inbound/axum_router/get_referral_code.rs@@ -1,7 +1,7 @@//! Handler for `GET /code`.use axum::{Json, extract::State};-use model_user::axum_extractor::MacroUserExtractor;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};use super::ReferralRouterState;use crate::domain::models::{ReferralCode, ReferralError};@@ -21,14 +21,14 @@ use crate::domain::ports::ReferralService;(status = 500, body = model_error_response::ErrorResponse),))]-#[tracing::instrument(skip(state, user_context), err)]-pub async fn get_referral_code_handler<T: ReferralService, R>(- State(state): State<ReferralRouterState<T, R>>,- user_context: MacroUserExtractor,+#[tracing::instrument(skip(state, authorization), err)]+pub async fn get_referral_code_handler<T: ReferralService, R, Auth: MacroAuthorizationService>(+ State(state): State<ReferralRouterState<T, R, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth>,) -> Result<Json<ReferralCode>, ReferralError> {let code = state.service- .get_referral_code_for_user(&user_context.macro_user_id)+ .get_referral_code_for_user(&authorization.macro_user_id).await?;Ok(Json(code))diff --git a/crates/referral/src/inbound/axum_router/send_invite.rs b/crates/referral/src/inbound/axum_router/send_invite.rsindex 95e1e30b11..d8ecc2f31d 100644--- a/crates/referral/src/inbound/axum_router/send_invite.rs+++ b/crates/referral/src/inbound/axum_router/send_invite.rs@@ -1,13 +1,16 @@//! Handler for `POST /send`.use axum::RequestPartsExt;-use axum::extract::FromRequestParts;+use axum::extract::{FromRef, FromRequestParts};use axum::http::StatusCode;use axum::{Json, extract::State};use axum_extra::extract::Cached;use ip_extractor::ClientIp;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationRejection, MacroAuthorizationService,+ MacroAuthorizationState,+};use macro_user_id::email::EmailStr;-use model_user::axum_extractor::MacroUserExtractor;use rate_limit::inbound::RateLimitExtractable;use rate_limit::{RateLimitConfig, RateLimitKey};use serde::Deserialize;@@ -39,26 +42,32 @@ pub struct SendInviteBody {(status = 500, body = model_error_response::ErrorResponse),))]-#[tracing::instrument(skip(state, user_context), err)]-pub async fn post_referral_invite_handler<T: ReferralService, R>(- State(state): State<ReferralRouterState<T, R>>,- Cached(user_context): Cached<MacroUserExtractor>,+#[tracing::instrument(skip(state, authorization), err)]+pub async fn post_referral_invite_handler<+ T: ReferralService,+ R,+ Auth: MacroAuthorizationService,+>(+ State(state): State<ReferralRouterState<T, R, Auth>>,+ Cached(authorization): Cached<MacroAuthorizationExtractor<Auth>>,Json(SendInviteBody { recipient }): Json<SendInviteBody>,) -> Result<StatusCode, ReferralError> {let () = state.service- .send_referral_invite(user_context.macro_user_id, recipient)+ .send_referral_invite(authorization.macro_user_id, recipient).await?;Ok(StatusCode::NO_CONTENT)}/// the rate limit definition for the per-user rate limit on referring new users-pub struct PerUserReferralRateLimit(MacroUserExtractor);+pub struct PerUserReferralRateLimit<Auth>(MacroAuthorizationExtractor<Auth>);-impl<S> RateLimitExtractable<S> for PerUserReferralRateLimit+impl<S, Auth> RateLimitExtractable<S> for PerUserReferralRateLimit<Auth>where- S: Send + Sync,+ S: Send + Sync + 'static,+ Auth: MacroAuthorizationService,+ MacroAuthorizationState<Auth>: FromRef<S>,{fn config() -> rate_limit::RateLimitConfig {// The fixed window rate limit config for the number of invites a user can send to others@@ -75,18 +84,21 @@ where}}-impl<S> FromRequestParts<S> for PerUserReferralRateLimit+impl<S, Auth> FromRequestParts<S> for PerUserReferralRateLimit<Auth>where- S: Send + Sync,+ S: Send + Sync + 'static,+ Auth: MacroAuthorizationService,+ MacroAuthorizationState<Auth>: FromRef<S>,{- type Rejection = <MacroUserExtractor as FromRequestParts<S>>::Rejection;+ type Rejection = MacroAuthorizationRejection;async fn from_request_parts(parts: &mut axum::http::request::Parts,state: &S,) -> Result<Self, Self::Rejection> {- let Cached(user): Cached<MacroUserExtractor> = parts.extract_with_state(state).await?;- Ok(Self(user))+ let Cached(authorization): Cached<MacroAuthorizationExtractor<Auth>> =+ parts.extract_with_state(state).await?;+ Ok(Self(authorization))}}diff --git a/crates/referral/src/inbound/axum_router/test.rs b/crates/referral/src/inbound/axum_router/test.rsindex b99583418d..50398a0b74 100644--- a/crates/referral/src/inbound/axum_router/test.rs+++ b/crates/referral/src/inbound/axum_router/test.rs@@ -1,8 +1,16 @@use std::net::SocketAddr;use std::sync::Arc;-use axum::{Extension, extract::ConnectInfo, http::StatusCode};+use axum::{+ Extension,+ extract::ConnectInfo,+ http::{StatusCode, header},+};use http_body_util::BodyExt;+use macro_authorization::{+ INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,+ MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,+};use model_user::UserContext;use rate_limit::{RateLimitConfig, RateLimitExceeded, RateLimitKey, RateLimitResult, RateLimitServiceImpl,@@ -15,6 +23,35 @@ use crate::domain::models::{ReferralCode, ReferralError};use crate::domain::ports::ReferralService;use crate::inbound::axum_router::{ReferralRouterState, referral_router};+const TEST_USER_ID: &str = "macro|[email protected]";+const INTERNAL_ACTING_USER_ID: &str = "macro|[email protected]";+const VALID_INTERNAL_KEY: &str = "valid-internal-key";++#[derive(Clone)]+struct FakeAuthorizationService;++impl MacroAuthorizationService for FakeAuthorizationService {+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {+ if jwt != "valid" {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }++ Ok(test_user_context(TEST_USER_ID))+ }++ async fn authorize_internal(+ &self,+ provided_key: &str,+ claims: InternalIdentityClaims,+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {+ if provided_key != VALID_INTERNAL_KEY {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }++ Ok(claims.user_id.map(|user_id| test_user_context(&user_id)))+ }+}+struct MockReferralService {result: Result<ReferralCode, ReferralError>,}@@ -109,9 +146,9 @@ fn exceeding_rate_limiter() -> RateLimitServiceImpl<MockRateLimitPort> {}}-fn test_user_context() -> UserContext {+fn test_user_context(user_id: &str) -> UserContext {UserContext {- user_id: "macro|[email protected]".to_string(),+ user_id: user_id.to_string(),fusion_user_id: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb".to_string(),permissions: None,organization_id: None,@@ -125,13 +162,12 @@ fn build_router(let state = ReferralRouterState {service: Arc::new(service),rate_limiter,+ authorization_state: MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),};- referral_router(state)- .layer(Extension(ConnectInfo(SocketAddr::from((- [127, 0, 0, 1],- 0,- )))))- .layer(Extension(test_user_context()))+ referral_router(state).layer(Extension(ConnectInfo(SocketAddr::from((+ [127, 0, 0, 1],+ 0,+ )))))}fn ok_service() -> MockReferralService {@@ -140,17 +176,28 @@ fn ok_service() -> MockReferralService {}}+fn get_code_request() -> axum::http::Request<axum::body::Body> {+ axum::http::Request::get("/code")+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(axum::body::Body::empty())+ .unwrap()+}++fn send_invite_request() -> axum::http::Request<axum::body::Body> {+ axum::http::Request::post("/send")+ .header(header::AUTHORIZATION, "Bearer valid")+ .header(header::CONTENT_TYPE, "application/json")+ .body(axum::body::Body::from(+ serde_json::json!({"recipient": "[email protected]"}).to_string(),+ ))+ .unwrap()+}+#[tokio::test]async fn test_get_referral_code_success() {let app = build_router(ok_service(), allowing_rate_limiter());- let request = axum::http::Request::builder()- .uri("/code")- .method("GET")- .body(axum::body::Body::empty())- .unwrap();-- let response = app.oneshot(request).await.unwrap();+ let response = app.oneshot(get_code_request()).await.unwrap();assert_eq!(response.status(), StatusCode::OK);@@ -166,29 +213,15 @@ async fn test_get_referral_code_internal_error() {};let app = build_router(service, allowing_rate_limiter());- let request = axum::http::Request::builder()- .uri("/code")- .method("GET")- .body(axum::body::Body::empty())- .unwrap();-- let response = app.oneshot(request).await.unwrap();+ let response = app.oneshot(get_code_request()).await.unwrap();assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);}#[tokio::test]async fn test_get_referral_code_unauthenticated() {- let state = ReferralRouterState {- service: Arc::new(ok_service()),- rate_limiter: allowing_rate_limiter(),- };- // No user context extension — should fail auth- let app: axum::Router = referral_router(state);-- let request = axum::http::Request::builder()- .uri("/code")- .method("GET")+ let app = build_router(ok_service(), allowing_rate_limiter());+ let request = axum::http::Request::get("/code").body(axum::body::Body::empty()).unwrap();@@ -198,20 +231,25 @@ async fn test_get_referral_code_unauthenticated() {}#[tokio::test]-async fn test_send_invite_succeeds_under_rate_limit() {+async fn test_get_referral_code_accepts_internal_acting_user() {let app = build_router(ok_service(), allowing_rate_limiter());-- let request = axum::http::Request::builder()- .uri("/send")- .method("POST")- .header("content-type", "application/json")- .body(axum::body::Body::from(- serde_json::json!({"recipient": "[email protected]"}).to_string(),- ))+ let request = axum::http::Request::get("/code")+ .header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)+ .header(INTERNAL_MACRO_USER_ID_HEADER, INTERNAL_ACTING_USER_ID)+ .body(axum::body::Body::empty()).unwrap();let response = app.oneshot(request).await.unwrap();+ assert_eq!(response.status(), StatusCode::OK);+}++#[tokio::test]+async fn test_send_invite_succeeds_under_rate_limit() {+ let app = build_router(ok_service(), allowing_rate_limiter());++ let response = app.oneshot(send_invite_request()).await.unwrap();+assert_eq!(response.status(), StatusCode::NO_CONTENT);}@@ -219,33 +257,16 @@ async fn test_send_invite_succeeds_under_rate_limit() {async fn test_send_invite_blocked_when_rate_limit_exceeded() {let app = build_router(ok_service(), exceeding_rate_limiter());- let request = axum::http::Request::builder()- .uri("/send")- .method("POST")- .header("content-type", "application/json")- .body(axum::body::Body::from(- serde_json::json!({"recipient": "[email protected]"}).to_string(),- ))- .unwrap();-- let response = app.oneshot(request).await.unwrap();+ let response = app.oneshot(send_invite_request()).await.unwrap();assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);}#[tokio::test]async fn test_send_invite_unauthenticated() {- let state = ReferralRouterState {- service: Arc::new(ok_service()),- rate_limiter: allowing_rate_limiter(),- };- // No user context extension — should fail auth- let app: axum::Router = referral_router(state);-- let request = axum::http::Request::builder()- .uri("/send")- .method("POST")- .header("content-type", "application/json")+ let app = build_router(ok_service(), allowing_rate_limiter());+ let request = axum::http::Request::post("/send")+ .header(header::CONTENT_TYPE, "application/json").body(axum::body::Body::from(serde_json::json!({"recipient": "[email protected]"}).to_string(),))@@ -258,17 +279,9 @@ async fn test_send_invite_unauthenticated() {#[tokio::test]async fn test_get_code_not_affected_by_rate_limit() {- // GET /code should succeed even when rate limiter would exceed,- // because rate limiting middleware only applies to /sendlet app = build_router(ok_service(), exceeding_rate_limiter());- let request = axum::http::Request::builder()- .uri("/code")- .method("GET")- .body(axum::body::Body::empty())- .unwrap();-- let response = app.oneshot(request).await.unwrap();+ let response = app.oneshot(get_code_request()).await.unwrap();assert_eq!(response.status(), StatusCode::OK);}diff --git a/crates/teams/Cargo.toml b/crates/teams/Cargo.tomlindex eb6322c6f9..b23af31119 100644--- a/crates/teams/Cargo.toml+++ b/crates/teams/Cargo.toml@@ -14,6 +14,7 @@ ai_tools = []axum = ["dep:axum",+ "dep:macro_authorization","dep:model-error-response","dep:model_user","dep:utoipa",@@ -49,6 +50,9 @@ async-stripe = { workspace = true, default-features = false, features = [] }async-trait = { workspace = true, optional = true }chrono = { workspace = true }+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = [+ "axum",+] }macro_user_id = { path = "../macro_user_id" }macro_uuid = { path = "../macro_uuid" }non_empty = { path = "../non_empty" }@@ -92,3 +96,4 @@ macro_db_migrator = { path = "../macro_db_migrator" }rootcause = { workspace = true }serde_json = { workspace = true }tokio = { workspace = true }+tower = { workspace = true }diff --git a/crates/teams/src/inbound/axum_router/create_team.rs b/crates/teams/src/inbound/axum_router/create_team.rsindex 128333abc7..9d810317c6 100644--- a/crates/teams/src/inbound/axum_router/create_team.rs+++ b/crates/teams/src/inbound/axum_router/create_team.rs@@ -1,5 +1,6 @@use axum::{Json, extract::State};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::MacroAuthorizationService;use crate::domain::{model::Team, team_repo::TeamService};@@ -25,9 +26,9 @@ pub struct CreateTeamRequest {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- State(state): State<TeamRouterState<T, Eas>>,- user: PremiumUserExtractor,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ State(state): State<TeamRouterState<T, Eas, Auth>>,+ user: PremiumUserExtractor<Auth>,Json(req): Json<CreateTeamRequest>,) -> Result<Json<Team>, crate::domain::model::CreateTeamError> {let team = statediff --git a/crates/teams/src/inbound/axum_router/delete_team.rs b/crates/teams/src/inbound/axum_router/delete_team.rsindex bc6f3668d6..79d4671e92 100644--- a/crates/teams/src/inbound/axum_router/delete_team.rs+++ b/crates/teams/src/inbound/axum_router/delete_team.rs@@ -1,8 +1,9 @@use axum::extract::State;use entity_access::{domain::{models::OwnerTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{model::DeleteTeamError, team_repo::TeamService};@@ -24,9 +25,9 @@ use super::TeamRouterState;),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<OwnerTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<OwnerTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,) -> Result<(), DeleteTeamError> {state.servicediff --git a/crates/teams/src/inbound/axum_router/delete_team_invite.rs b/crates/teams/src/inbound/axum_router/delete_team_invite.rsindex b99936ce1f..a8ef373d3f 100644--- a/crates/teams/src/inbound/axum_router/delete_team_invite.rs+++ b/crates/teams/src/inbound/axum_router/delete_team_invite.rs@@ -1,8 +1,9 @@use axum::extract::{Path, State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{model::RemoveTeamInviteError, team_repo::TeamService};@@ -33,9 +34,9 @@ pub struct Param {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,Path(Param { team_invite_id }): Path<Param>,) -> Result<(), RemoveTeamInviteError> {statediff --git a/crates/teams/src/inbound/axum_router/get_team.rs b/crates/teams/src/inbound/axum_router/get_team.rsindex 073f5dd757..3fb930e7ef 100644--- a/crates/teams/src/inbound/axum_router/get_team.rs+++ b/crates/teams/src/inbound/axum_router/get_team.rs@@ -6,8 +6,9 @@ use axum::{};use entity_access::{domain::{models::MemberTeamRole, ports::EntityAccessService},- inbound::axum_extractors::OptionalMacroUserTeamExtractor,+ inbound::axum_extractors::OptionalMacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{@@ -32,9 +33,9 @@ use super::TeamRouterState;),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: OptionalMacroUserTeamExtractor<MemberTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: OptionalMacroUserTeamExtractorV2<MemberTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,) -> Result<Response, TeamError> {let Some(receipt) = access.entity_access_receipt else {return Ok(StatusCode::NO_CONTENT.into_response());diff --git a/crates/teams/src/inbound/axum_router/get_team_invites.rs b/crates/teams/src/inbound/axum_router/get_team_invites.rsindex 31a650c056..e5004a0b93 100644--- a/crates/teams/src/inbound/axum_router/get_team_invites.rs+++ b/crates/teams/src/inbound/axum_router/get_team_invites.rs@@ -1,8 +1,9 @@use axum::{Json, extract::State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{@@ -32,9 +33,9 @@ pub struct TeamInvitesResponse {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,) -> Result<Json<TeamInvitesResponse>, TeamError> {let invites = state.servicediff --git a/crates/teams/src/inbound/axum_router/get_user_invites.rs b/crates/teams/src/inbound/axum_router/get_user_invites.rsindex 723baa00ea..cab99154cd 100644--- a/crates/teams/src/inbound/axum_router/get_user_invites.rs+++ b/crates/teams/src/inbound/axum_router/get_user_invites.rs@@ -1,7 +1,7 @@use axum::{Json, extract::State};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use crate::domain::{model::{TeamError, TeamInviteDetails},@@ -30,13 +30,13 @@ pub struct TeamInvitesResponse {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- State(state): State<TeamRouterState<T, Eas>>,- user_context: MacroUserExtractor,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ State(state): State<TeamRouterState<T, Eas, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth>,) -> Result<Json<TeamInvitesResponse>, TeamError> {let invites = state.service- .get_user_invites(&user_context.macro_user_id)+ .get_user_invites(&authorization.macro_user_id).await?;Ok(Json(TeamInvitesResponse { invites }))}diff --git a/crates/teams/src/inbound/axum_router/get_user_teams.rs b/crates/teams/src/inbound/axum_router/get_user_teams.rsindex 96726018db..05710f76d6 100644--- a/crates/teams/src/inbound/axum_router/get_user_teams.rs+++ b/crates/teams/src/inbound/axum_router/get_user_teams.rs@@ -1,7 +1,7 @@use axum::{Json, extract::State};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use crate::domain::{model::{Team, TeamError},@@ -23,13 +23,13 @@ use super::TeamRouterState;),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- State(state): State<TeamRouterState<T, Eas>>,- user_context: MacroUserExtractor,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ State(state): State<TeamRouterState<T, Eas, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth>,) -> Result<Json<Vec<Team>>, TeamError> {let teams = state.service- .get_user_teams(&user_context.macro_user_id)+ .get_user_teams(&authorization.macro_user_id).await?;Ok(Json(teams))}diff --git a/crates/teams/src/inbound/axum_router/invite_to_team.rs b/crates/teams/src/inbound/axum_router/invite_to_team.rsindex fbe38c5d82..547368979b 100644--- a/crates/teams/src/inbound/axum_router/invite_to_team.rs+++ b/crates/teams/src/inbound/axum_router/invite_to_team.rs@@ -1,8 +1,9 @@use axum::{Json, extract::State, http::StatusCode};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use macro_user_id::{email::Email, lowercased::Lowercase};use model_error_response::ErrorResponse;@@ -94,9 +95,9 @@ impl axum::response::IntoResponse for InviteToTeamError {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,Json(req): Json<InviteToTeamRequest>,) -> Result<StatusCode, InviteToTeamError> {let parsed: Vec<Result<Email<Lowercase<'_>>, _>> = reqdiff --git a/crates/teams/src/inbound/axum_router/join_team.rs b/crates/teams/src/inbound/axum_router/join_team.rsindex 67a1a40971..18babbee87 100644--- a/crates/teams/src/inbound/axum_router/join_team.rs+++ b/crates/teams/src/inbound/axum_router/join_team.rs@@ -1,7 +1,7 @@use axum::extract::{Path, State};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use crate::domain::{model::JoinTeamError, team_repo::TeamService};@@ -30,14 +30,14 @@ pub struct TeamInvitePathParam {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- State(state): State<TeamRouterState<T, Eas>>,- user_context: MacroUserExtractor,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ State(state): State<TeamRouterState<T, Eas, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth>,Path(TeamInvitePathParam { team_invite_id }): Path<TeamInvitePathParam>,) -> Result<(), JoinTeamError> {state.service- .join_team(&team_invite_id, &user_context.macro_user_id)+ .join_team(&team_invite_id, &authorization.macro_user_id).await?;Ok(())}diff --git a/crates/teams/src/inbound/axum_router/mod.rs b/crates/teams/src/inbound/axum_router/mod.rsindex 68f373cc03..7619b7f96c 100644--- a/crates/teams/src/inbound/axum_router/mod.rs+++ b/crates/teams/src/inbound/axum_router/mod.rs@@ -44,6 +44,7 @@ use axum::{routing::{delete, get, patch, post},};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use crate::domain::{@@ -55,62 +56,81 @@ use crate::domain::{};/// Router state containing the team service.-pub struct TeamRouterState<T, Eas> {+pub struct TeamRouterState<T, Eas, Auth> {/// The team service implementation.pub service: Arc<T>,/// The entity access service.pub entity_access_service: Arc<Eas>,+ /// State for request authorization.+ pub authorization_state: MacroAuthorizationState<Auth>,}-impl<T, Eas> FromRef<TeamRouterState<T, Eas>> for Arc<Eas> {- fn from_ref(state: &TeamRouterState<T, Eas>) -> Self {+impl<T, Eas, Auth> FromRef<TeamRouterState<T, Eas, Auth>> for Arc<Eas> {+ fn from_ref(state: &TeamRouterState<T, Eas, Auth>) -> Self {state.entity_access_service.clone()}}-// Manual Clone impl so T, Eas doesn't need to be Clone (it's behind Arc).-impl<T, Eas> Clone for TeamRouterState<T, Eas> {+impl<T, Eas, Auth> FromRef<TeamRouterState<T, Eas, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &TeamRouterState<T, Eas, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++// Manual Clone impl so T, Eas, and Auth don't need to be Clone.+impl<T, Eas, Auth> Clone for TeamRouterState<T, Eas, Auth> {fn clone(&self) -> Self {Self {service: self.service.clone(),entity_access_service: self.entity_access_service.clone(),+ authorization_state: self.authorization_state.clone(),}}}/// Build the teams router with all endpoints.-pub fn teams_router<T, Eas, S>(state: TeamRouterState<T, Eas>) -> Router<S>+pub fn teams_router<T, Eas, Auth, S>(state: TeamRouterState<T, Eas, Auth>) -> Router<S>whereT: TeamService,Eas: EntityAccessService,+ Auth: MacroAuthorizationService,S: Send + Sync + 'static,{Router::new()- .route("/", post(create_team::handler::<T, Eas>))- .route("/join/{team_invite_id}", get(join_team::handler::<T, Eas>))- .route("/user", get(get_user_teams::handler::<T, Eas>))- .route("/user/invites", get(get_user_invites::handler::<T, Eas>))- .route("/", get(get_team::handler::<T, Eas>))- .route("/", patch(patch_team::handler::<T, Eas>))- .route("/", delete(delete_team::handler::<T, Eas>))- .route("/crm", patch(patch_team_crm_settings::handler::<T, Eas>))+ .route("/", post(create_team::handler::<T, Eas, Auth>))+ .route(+ "/join/{team_invite_id}",+ get(join_team::handler::<T, Eas, Auth>),+ )+ .route("/user", get(get_user_teams::handler::<T, Eas, Auth>))+ .route(+ "/user/invites",+ get(get_user_invites::handler::<T, Eas, Auth>),+ )+ .route("/", get(get_team::handler::<T, Eas, Auth>))+ .route("/", patch(patch_team::handler::<T, Eas, Auth>))+ .route("/", delete(delete_team::handler::<T, Eas, Auth>))+ .route(+ "/crm",+ patch(patch_team_crm_settings::handler::<T, Eas, Auth>),+ ).route("/auto-join-domain/toggle",- post(toggle_auto_join_domain::handler::<T, Eas>),+ post(toggle_auto_join_domain::handler::<T, Eas, Auth>),)- .route("/invites", get(get_team_invites::handler::<T, Eas>))- .route("/invite", post(invite_to_team::handler::<T, Eas>))+ .route("/invites", get(get_team_invites::handler::<T, Eas, Auth>))+ .route("/invite", post(invite_to_team::handler::<T, Eas, Auth>)).route("/join/{team_invite_id}",- delete(reject_invitation::handler::<T, Eas>),+ delete(reject_invitation::handler::<T, Eas, Auth>),).route("/remove/{remove_user_id}",- delete(remove_user_from_team::handler::<T, Eas>),+ delete(remove_user_from_team::handler::<T, Eas, Auth>),).route("/invite/{team_invite_id}",- delete(delete_team_invite::handler::<T, Eas>),+ delete(delete_team_invite::handler::<T, Eas, Auth>),).with_state(state)}diff --git a/crates/teams/src/inbound/axum_router/patch_team.rs b/crates/teams/src/inbound/axum_router/patch_team.rsindex cbfbcae851..1ff866379f 100644--- a/crates/teams/src/inbound/axum_router/patch_team.rs+++ b/crates/teams/src/inbound/axum_router/patch_team.rs@@ -1,8 +1,9 @@use axum::{Json, extract::State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{@@ -27,9 +28,9 @@ use super::TeamRouterState;),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,Json(req): Json<PatchTeamRequest>,) -> Result<(), TeamError> {statediff --git a/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rs b/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rsindex a647b25454..7eff8c50ae 100644--- a/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rs+++ b/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rs@@ -1,8 +1,9 @@use axum::{Json, extract::State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{@@ -36,9 +37,9 @@ use super::TeamRouterState;),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,Json(req): Json<PatchTeamCrmSettingsRequest>,) -> Result<Json<PatchTeamCrmSettingsResponse>, TeamError> {let response = statediff --git a/crates/teams/src/inbound/axum_router/premium_user.rs b/crates/teams/src/inbound/axum_router/premium_user.rsindex 2b47d472e5..c41ee520b2 100644--- a/crates/teams/src/inbound/axum_router/premium_user.rs+++ b/crates/teams/src/inbound/axum_router/premium_user.rs@@ -1,5 +1,7 @@//! Extractor that ensures the authenticated user is a premium user.+use std::marker::PhantomData;+use axum::{Json,extract::FromRequestParts,@@ -7,9 +9,11 @@ use axum::{response::{IntoResponse, Response},};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationRejection, MacroAuthorizationService,+};use macro_user_id::user_id::MacroUserIdStr;use model_error_response::ErrorResponse;-use model_user::axum_extractor::{MacroUserExtractor, UserExtractorErr};use crate::domain::{model::TeamError, team_repo::TeamService};@@ -17,19 +21,20 @@ use super::TeamRouterState;/// Extractor that ensures the authenticated user is a premium user/// (has an active stripe subscription).-pub struct PremiumUserExtractor {+pub struct PremiumUserExtractor<Auth> {/// The authenticated premium user's id.pub macro_user_id: MacroUserIdStr<'static>,/// The authenticated premium user's active Stripe subscription id.pub subscription_id: stripe::SubscriptionId,+ _authorization: PhantomData<fn() -> Auth>,}/// Rejection returned when the premium user check fails.#[derive(Debug, thiserror::Error)]pub enum PremiumUserRejection {- /// The user could not be extracted from the request.- #[error(transparent)]- User(#[from] UserExtractorErr),+ /// The request could not be authorized.+ #[error("authorization failed")]+ Authorization(MacroAuthorizationRejection),/// The user does not have an active subscription.#[error("active subscription required")]NotPremium,@@ -41,7 +46,7 @@ pub enum PremiumUserRejection {impl IntoResponse for PremiumUserRejection {fn into_response(self) -> Response {match self {- PremiumUserRejection::User(err) => err.into_response(),+ PremiumUserRejection::Authorization(rejection) => rejection.into_response(),PremiumUserRejection::NotPremium => (StatusCode::FORBIDDEN,Json(ErrorResponse {@@ -60,19 +65,26 @@ impl IntoResponse for PremiumUserRejection {}}-impl<T, Eas> FromRequestParts<TeamRouterState<T, Eas>> for PremiumUserExtractor+impl From<MacroAuthorizationRejection> for PremiumUserRejection {+ fn from(rejection: MacroAuthorizationRejection) -> Self {+ Self::Authorization(rejection)+ }+}++impl<T, Eas, Auth> FromRequestParts<TeamRouterState<T, Eas, Auth>> for PremiumUserExtractor<Auth>whereT: TeamService,Eas: EntityAccessService,+ Auth: MacroAuthorizationService,{type Rejection = PremiumUserRejection;#[tracing::instrument(err, skip(parts, state))]async fn from_request_parts(parts: &mut Parts,- state: &TeamRouterState<T, Eas>,+ state: &TeamRouterState<T, Eas, Auth>,) -> Result<Self, Self::Rejection> {- let user = MacroUserExtractor::from_request_parts(parts, state).await?;+ let user = MacroAuthorizationExtractor::<Auth>::from_request_parts(parts, state).await?;let Some(subscription_id) = state.service.is_user_premium(&user.macro_user_id).await?else {@@ -82,6 +94,7 @@ whereOk(Self {macro_user_id: user.macro_user_id,subscription_id,+ _authorization: PhantomData,})}}diff --git a/crates/teams/src/inbound/axum_router/reject_invitation.rs b/crates/teams/src/inbound/axum_router/reject_invitation.rsindex 75cf13dee7..c6a6ff14cd 100644--- a/crates/teams/src/inbound/axum_router/reject_invitation.rs+++ b/crates/teams/src/inbound/axum_router/reject_invitation.rs@@ -1,7 +1,7 @@use axum::extract::{Path, State};use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use crate::domain::{model::RemoveTeamInviteError, team_repo::TeamService};@@ -30,14 +30,14 @@ pub struct TeamInvitePathParam {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- State(state): State<TeamRouterState<T, Eas>>,- user_context: MacroUserExtractor,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ State(state): State<TeamRouterState<T, Eas, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth>,Path(TeamInvitePathParam { team_invite_id }): Path<TeamInvitePathParam>,) -> Result<(), RemoveTeamInviteError> {state.service- .reject_invitation(&user_context.macro_user_id, &team_invite_id)+ .reject_invitation(&authorization.macro_user_id, &team_invite_id).await?;Ok(())}diff --git a/crates/teams/src/inbound/axum_router/remove_user_from_team.rs b/crates/teams/src/inbound/axum_router/remove_user_from_team.rsindex 1a11da53e6..279ad3eb1d 100644--- a/crates/teams/src/inbound/axum_router/remove_user_from_team.rs+++ b/crates/teams/src/inbound/axum_router/remove_user_from_team.rs@@ -1,8 +1,9 @@use axum::extract::{Path, State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use macro_user_id::user_id::MacroUserIdStr;use model_error_response::ErrorResponse;@@ -33,9 +34,9 @@ pub struct Param {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,Path(Param { remove_user_id }): Path<Param>,) -> Result<(), RemoveUserFromTeamError> {statediff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rsindex 7f1094aef3..d8de494421 100644--- a/crates/teams/src/inbound/axum_router/test.rs+++ b/crates/teams/src/inbound/axum_router/test.rs@@ -1,12 +1,52 @@-use axum::{body::to_bytes, http::StatusCode, response::IntoResponse};+use std::{+ collections::HashSet,+ sync::{Arc, Mutex},+};++use axum::{+ Json, Router,+ body::{Body, to_bytes},+ http::{Request, StatusCode, header},+ response::IntoResponse,+};+use entity_access::domain::{+ models::{+ AccessError, AccessLevel, AdminTeamRole, BotId, CallChannelInfo, EntityAccessReceipt,+ EntityPermission, EntityType, RequiredPermission, TeamRole, UserTeamInfo,+ },+ ports::EntityAccessService,+};+use macro_authorization::{+ INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,+ MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,+};+use macro_user_id::{+ email::Email,+ lowercased::Lowercase,+ user_id::{MacroUserId, MacroUserIdStr},+};+use model_error_response::ErrorResponse;+use model_user::UserContext;+use roles_and_permissions::domain::model::PermissionId;+use rootcause::Report;use serde_json::{Value, json};+use tower::ServiceExt;-use crate::domain::model::{- CustomerError, DeleteTeamError, InviteUsersToTeamError, JoinTeamError, RemoveTeamInviteError,- RemoveUserFromTeamError, TeamError, ToggleAutoJoinDomainError,+use crate::domain::{+ model::{+ CreateTeamError, CustomerError, DeleteTeamError, InviteUsersToTeamError, JoinTeamError,+ PatchTeamCrmSettingsResponse, PatchTeamRequest, RemoveTeamInviteError,+ RemoveUserFromTeamError, RestorePermissionsForTeamMembersError,+ RevokePermissionsForTeamMembersError, Team, TeamError, TeamInvite, TeamInviteDetails,+ TeamMember, TeamWithMembers, ToggleAutoJoinDomainError, TryJoinTeamByDomainError,+ },+ team_repo::TeamService,};-use super::invite_to_team::InviteToTeamError;+use super::{+ TeamRouterState, invite_to_team::InviteToTeamError, premium_user::PremiumUserRejection,+ teams_router,+};const CUSTOMER_ERROR_SENTINEL: &str = "sentinel customer repository failure";@@ -132,3 +172,488 @@ async fn toggle_auto_join_domain_missing_team_response_is_not_found() {assert_eq!(status, StatusCode::NOT_FOUND);assert_eq!(body_text, r#"{"message":"team does not exist"}"#);}++const USER_ID: &str = "macro|[email protected]";+const ACTING_USER_ID: &str = "macro|[email protected]";+const INTERNAL_KEY: &str = "valid-internal-key";+const TEAM_ID: uuid::Uuid = uuid::Uuid::from_u128(42);++#[derive(Clone, Debug, Eq, PartialEq)]+struct TeamReceiptCall {+ user_id: String,+ team_id: String,+ role: TeamRole,+}++#[derive(Clone, Default)]+struct FakeTeamService {+ user_calls: Arc<Mutex<Vec<String>>>,+ team_receipt_calls: Arc<Mutex<Vec<TeamReceiptCall>>>,+}++impl FakeTeamService {+ fn user_calls(&self) -> Vec<String> {+ self.user_calls+ .lock()+ .expect("user calls lock poisoned")+ .clone()+ }++ fn team_receipt_calls(&self) -> Vec<TeamReceiptCall> {+ self.team_receipt_calls+ .lock()+ .expect("team receipt calls lock poisoned")+ .clone()+ }+}++impl TeamService for FakeTeamService {+ async fn create_team(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ _team_name: &str,+ _subscription_id: &stripe::SubscriptionId,+ ) -> Result<Team, CreateTeamError> {+ panic!("unexpected create_team call")+ }++ async fn is_user_premium(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<Option<stripe::SubscriptionId>, TeamError> {+ panic!("unexpected is_user_premium call")+ }++ async fn invite_users_to_team(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ _invites: non_empty::NonEmpty<&[Email<Lowercase<'_>>]>,+ ) -> Result<Vec<TeamInvite<'_>>, InviteUsersToTeamError> {+ panic!("unexpected invite_users_to_team call")+ }++ async fn remove_user_from_team(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<(), RemoveUserFromTeamError> {+ panic!("unexpected remove_user_from_team call")+ }++ async fn reject_invitation(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ _team_invite_id: &uuid::Uuid,+ ) -> Result<(), RemoveTeamInviteError> {+ panic!("unexpected reject_invitation call")+ }++ async fn delete_team_invite(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ _team_invite_id: &uuid::Uuid,+ ) -> Result<(), RemoveTeamInviteError> {+ panic!("unexpected delete_team_invite call")+ }++ async fn delete_team(+ &self,+ _entity_access_receipt: EntityAccessReceipt<entity_access::domain::models::OwnerTeamRole>,+ ) -> Result<(), DeleteTeamError> {+ panic!("unexpected delete_team call")+ }++ async fn join_team(+ &self,+ _team_invite_id: &uuid::Uuid,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<TeamMember<'_>, JoinTeamError> {+ panic!("unexpected join_team call")+ }++ async fn revoke_permissions_for_team_members(+ &self,+ _team_id: &uuid::Uuid,+ ) -> Result<(), RevokePermissionsForTeamMembersError> {+ panic!("unexpected revoke_permissions_for_team_members call")+ }++ async fn restore_permissions_for_team_members(+ &self,+ _team_id: &uuid::Uuid,+ ) -> Result<(), RestorePermissionsForTeamMembersError> {+ panic!("unexpected restore_permissions_for_team_members call")+ }++ async fn patch_team_subscription_id(+ &self,+ _team_id: &uuid::Uuid,+ _subscription_id: &stripe::SubscriptionId,+ ) -> Result<(), TeamError> {+ panic!("unexpected patch_team_subscription_id call")+ }++ async fn patch_team_payment_status(+ &self,+ _team_id: &uuid::Uuid,+ _paying: bool,+ ) -> Result<(), TeamError> {+ panic!("unexpected patch_team_payment_status call")+ }++ async fn get_team(+ &self,+ _entity_access_receipt: EntityAccessReceipt<entity_access::domain::models::MemberTeamRole>,+ ) -> Result<TeamWithMembers, TeamError> {+ panic!("unexpected get_team call")+ }++ async fn get_user_teams(&self, user_id: &MacroUserIdStr<'_>) -> Result<Vec<Team>, TeamError> {+ self.user_calls+ .lock()+ .expect("user calls lock poisoned")+ .push(user_id.to_string());+ Ok(Vec::new())+ }++ async fn get_user_invites(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<Vec<TeamInviteDetails>, TeamError> {+ panic!("unexpected get_user_invites call")+ }++ async fn get_team_invites(+ &self,+ entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ ) -> Result<Vec<TeamInviteDetails>, TeamError> {+ let user_id = entity_access_receipt+ .get_authenticated_user()+ .expect("team receipts should authenticate a user")+ .to_string();+ let EntityPermission::TeamRole { role } = entity_access_receipt.entity_permission() else {+ panic!("team receipt should contain a team role")+ };+ self.team_receipt_calls+ .lock()+ .expect("team receipt calls lock poisoned")+ .push(TeamReceiptCall {+ user_id,+ team_id: entity_access_receipt.entity().entity_id.clone(),+ role: *role,+ });+ Ok(Vec::new())+ }++ async fn patch_team(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ _req: &PatchTeamRequest,+ ) -> Result<(), TeamError> {+ panic!("unexpected patch_team call")+ }++ async fn get_team_user_permissions(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<HashSet<PermissionId>, TeamError> {+ panic!("unexpected get_team_user_permissions call")+ }++ async fn set_team_crm_enabled(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ _enabled: bool,+ _backfill: bool,+ ) -> Result<PatchTeamCrmSettingsResponse, TeamError> {+ panic!("unexpected set_team_crm_enabled call")+ }++ async fn toggle_auto_join_domain(+ &self,+ _entity_access_receipt: EntityAccessReceipt<AdminTeamRole>,+ ) -> Result<Option<String>, ToggleAutoJoinDomainError> {+ panic!("unexpected toggle_auto_join_domain call")+ }++ async fn try_join_team_by_domain(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<Option<TeamMember<'static>>, TryJoinTeamByDomainError> {+ panic!("unexpected try_join_team_by_domain call")+ }+}++#[derive(Clone, Default)]+struct FakeEntityAccessService {+ membership: Option<(String, TeamRole)>,+}++impl FakeEntityAccessService {+ fn with_membership(user_id: &str, role: TeamRole) -> Self {+ Self {+ membership: Some((user_id.to_string(), role)),+ }+ }+}++impl EntityAccessService for FakeEntityAccessService {+ async fn generate_entity_access_receipt<T: RequiredPermission>(+ &self,+ _user_id: &MacroUserId<Lowercase<'_>>,+ _user_org_id: Option<i64>,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<EntityAccessReceipt<T>, AccessError> {+ panic!("unexpected generate_entity_access_receipt call")+ }++ async fn generate_bot_entity_access_receipt<T: RequiredPermission>(+ &self,+ _bot_id: BotId,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<EntityAccessReceipt<T>, AccessError> {+ panic!("unexpected generate_bot_entity_access_receipt call")+ }++ async fn get_access_level(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<Option<AccessLevel>, AccessError> {+ panic!("unexpected get_access_level call")+ }++ async fn check_access(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ _required_level: AccessLevel,+ ) -> Result<AccessLevel, AccessError> {+ panic!("unexpected check_access call")+ }++ async fn check_public_access(+ &self,+ _entity_id: &str,+ _entity_type: EntityType,+ _required_level: AccessLevel,+ ) -> Result<AccessLevel, AccessError> {+ panic!("unexpected check_public_access call")+ }++ async fn get_entity_permission(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ _user_org_id: Option<i64>,+ ) -> Result<EntityPermission, AccessError> {+ panic!("unexpected get_entity_permission call")+ }++ async fn get_crm_entity_permission_with_team(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<(EntityPermission, uuid::Uuid), AccessError> {+ panic!("unexpected get_crm_entity_permission_with_team call")+ }++ async fn get_users_by_entity(+ &self,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<Vec<MacroUserIdStr<'static>>, AccessError> {+ panic!("unexpected get_users_by_entity call")+ }++ async fn get_call_channel(+ &self,+ _call_id: &uuid::Uuid,+ ) -> Result<Option<CallChannelInfo>, AccessError> {+ panic!("unexpected get_call_channel call")+ }++ async fn get_call_channel_by_channel_id(+ &self,+ _channel_id: &uuid::Uuid,+ ) -> Result<Option<CallChannelInfo>, AccessError> {+ panic!("unexpected get_call_channel_by_channel_id call")+ }++ async fn get_user_team(+ &self,+ user_id: &MacroUserId<Lowercase<'_>>,+ ) -> Result<Option<UserTeamInfo>, AccessError> {+ let Some((member_id, role)) = &self.membership else {+ return Ok(None);+ };+ if member_id != user_id.as_ref() {+ return Ok(None);+ }+ Ok(Some(UserTeamInfo {+ team_id: TEAM_ID,+ role: *role,+ }))+ }+}++#[derive(Clone, Default)]+struct FakeAuthorizationService;++impl MacroAuthorizationService for FakeAuthorizationService {+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {+ if jwt == "valid" {+ return Ok(user_context(USER_ID));+ }+ Err(Report::new(MacroAuthorizationError::InvalidCredentials))+ }++ async fn authorize_internal(+ &self,+ provided_key: &str,+ claims: InternalIdentityClaims,+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {+ if provided_key != INTERNAL_KEY {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }+ Ok(claims.user_id.as_deref().map(user_context))+ }+}++fn user_context(user_id: &str) -> UserContext {+ UserContext {+ user_id: user_id.to_string(),+ fusion_user_id: "fusion-user-id".to_string(),+ organization_id: None,+ permissions: None,+ }+}++fn router(service: FakeTeamService, entity_access: FakeEntityAccessService) -> Router {+ teams_router(TeamRouterState {+ service: Arc::new(service),+ entity_access_service: Arc::new(entity_access),+ authorization_state: MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),+ })+}++fn get_user_teams_request() -> axum::http::request::Builder {+ Request::get("/user")+}++#[tokio::test]+async fn teams_router_authorizes_bearer_credentials() {+ let service = FakeTeamService::default();+ let response = router(service.clone(), FakeEntityAccessService::default())+ .oneshot(+ get_user_teams_request()+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(service.user_calls(), vec![USER_ID]);+}++#[tokio::test]+async fn teams_router_rejects_missing_credentials() {+ let service = FakeTeamService::default();+ let response = router(service.clone(), FakeEntityAccessService::default())+ .oneshot(+ get_user_teams_request()+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");+ let (status, body, _) = response_parts(response).await;++ assert_eq!(status, StatusCode::UNAUTHORIZED);+ assert_eq!(body, r#"{"message":"unauthorized"}"#);+ assert!(service.user_calls().is_empty());+}++#[tokio::test]+async fn teams_router_accepts_internal_acting_user_credentials() {+ let service = FakeTeamService::default();+ let response = router(service.clone(), FakeEntityAccessService::default())+ .oneshot(+ get_user_teams_request()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .header(INTERNAL_MACRO_USER_ID_HEADER, ACTING_USER_ID)+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(service.user_calls(), vec![ACTING_USER_ID]);+}++#[tokio::test]+async fn teams_router_uses_entity_access_team_receipts() {+ let admin_service = FakeTeamService::default();+ let admin_response = router(+ admin_service.clone(),+ FakeEntityAccessService::with_membership(USER_ID, TeamRole::Admin),+ )+ .oneshot(+ Request::get("/invites")+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");++ assert_eq!(admin_response.status(), StatusCode::OK);+ assert_eq!(+ admin_service.team_receipt_calls(),+ vec![TeamReceiptCall {+ user_id: USER_ID.to_string(),+ team_id: TEAM_ID.to_string(),+ role: TeamRole::Admin,+ }]+ );++ let member_service = FakeTeamService::default();+ let member_response = router(+ member_service.clone(),+ FakeEntityAccessService::with_membership(USER_ID, TeamRole::Member),+ )+ .oneshot(+ Request::get("/invites")+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");++ assert_eq!(member_response.status(), StatusCode::UNAUTHORIZED);+ assert!(member_service.team_receipt_calls().is_empty());+}++#[tokio::test]+async fn premium_user_authorization_rejection_preserves_response() {+ let rejection = PremiumUserRejection::Authorization((+ StatusCode::FORBIDDEN,+ Json(ErrorResponse {+ message: "authorization denied".into(),+ }),+ ));+ let (status, body, _) = response_parts(rejection).await;++ assert_eq!(status, StatusCode::FORBIDDEN);+ assert_eq!(body, r#"{"message":"authorization denied"}"#);+}diff --git a/crates/teams/src/inbound/axum_router/toggle_auto_join_domain.rs b/crates/teams/src/inbound/axum_router/toggle_auto_join_domain.rsindex 7c97f1c1fb..a5664c1b2f 100644--- a/crates/teams/src/inbound/axum_router/toggle_auto_join_domain.rs+++ b/crates/teams/src/inbound/axum_router/toggle_auto_join_domain.rs@@ -1,8 +1,9 @@use axum::{Json, extract::State};use entity_access::{domain::{models::AdminTeamRole, ports::EntityAccessService},- inbound::axum_extractors::MacroUserTeamExtractor,+ inbound::axum_extractors::MacroUserTeamExtractorV2,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use crate::domain::{model::ToggleAutoJoinDomainError, team_repo::TeamService};@@ -37,9 +38,9 @@ pub struct ToggleAutoJoinDomainResponse {),)]#[tracing::instrument(skip_all, err)]-pub async fn handler<T: TeamService, Eas: EntityAccessService>(- access: MacroUserTeamExtractor<AdminTeamRole, Eas>,- State(state): State<TeamRouterState<T, Eas>>,+pub async fn handler<T: TeamService, Eas: EntityAccessService, Auth: MacroAuthorizationService>(+ access: MacroUserTeamExtractorV2<AdminTeamRole, Eas, Auth>,+ State(state): State<TeamRouterState<T, Eas, Auth>>,) -> Result<Json<ToggleAutoJoinDomainResponse>, ToggleAutoJoinDomainError> {let auto_join_domain = state.servicediff --git a/crates/webhook/Cargo.toml b/crates/webhook/Cargo.tomlindex 0765ffb539..d4fe513425 100644--- a/crates/webhook/Cargo.toml+++ b/crates/webhook/Cargo.toml@@ -17,6 +17,7 @@ default = ["consumer", "inbound", "outbound", "ports"]inbound = ["dep:axum","dep:axum-extra",+ "dep:macro_authorization","dep:model-error-response","dep:model_user","dep:rate_limit",@@ -62,6 +63,9 @@ entity_access = { path = "../entity_access", default-features = false, featuresfutures = { workspace = true, optional = true }hex = { workspace = true, optional = true }hmac = { workspace = true, optional = true }+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = [+ "axum",+] }macro_env = { path = "../macro_env", optional = true }macro_event_broker = { path = "../macro_event_broker", default-features = false, optional = true }macro_event_topics = { path = "../macro_event_topics", optional = true }@@ -72,6 +76,7 @@ model_user = { path = "../model_user", optional = true, features = ["axum"] }rate_limit = { path = "../rate_limit", optional = true, default-features = false }rdkafka = { workspace = true, optional = true }reqwest = { workspace = true, optional = true }+rootcause = { workspace = true }serde = { workspace = true }serde_json = { workspace = true, optional = true }sha2 = { workspace = true, optional = true }@@ -93,5 +98,4 @@ rate_limit = { path = "../rate_limit", default-features = false, features = ["axum","testing",] }-rootcause = { workspace = true }tower = { workspace = true }diff --git a/crates/webhook/src/inbound/axum_router.rs b/crates/webhook/src/inbound/axum_router.rsindex ad5e2430f2..c4a656fec9 100644--- a/crates/webhook/src/inbound/axum_router.rs+++ b/crates/webhook/src/inbound/axum_router.rs@@ -15,44 +15,61 @@ use axum::{routing::{patch, post},};use axum_extra::extract::Cached;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState,+};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;+use rate_limit::domain::models::RateLimitOk;use rate_limit::inbound::{RateLimitExtractable, rate_limit_middleware};-use rate_limit::{RateLimitConfig, RateLimitKey, RateLimitService};+use rate_limit::{RateLimitConfig, RateLimitKey, RateLimitResult, RateLimitService};+use rootcause::Report;use std::sync::Arc;use std::time::Duration;/// State for the webhook router.-pub struct WebhookRouterState<S, R> {+pub struct WebhookRouterState<S, R, Auth> {service: Arc<S>,rate_limiter: R,+ authorization_state: MacroAuthorizationState<Auth>,}-impl<S, R: Clone> Clone for WebhookRouterState<S, R> {+impl<S, R: Clone, Auth> Clone for WebhookRouterState<S, R, Auth> {fn clone(&self) -> Self {Self {service: self.service.clone(),rate_limiter: self.rate_limiter.clone(),+ authorization_state: self.authorization_state.clone(),}}}-impl<S: WebhookService, R: RateLimitService + Clone> WebhookRouterState<S, R> {+impl<S: WebhookService, R: RateLimitService + Clone, Auth> WebhookRouterState<S, R, Auth> {/// Create webhook router state.- pub fn new(service: S, rate_limiter: R) -> Self {+ pub fn new(+ service: S,+ rate_limiter: R,+ authorization_state: MacroAuthorizationState<Auth>,+ ) -> Self {Self {service: Arc::new(service),rate_limiter,+ authorization_state,}}}-impl<S, R: Clone> FromRef<WebhookRouterState<S, R>> for Arc<S> {- fn from_ref(state: &WebhookRouterState<S, R>) -> Self {+impl<S, R, Auth> FromRef<WebhookRouterState<S, R, Auth>> for Arc<S> {+ fn from_ref(state: &WebhookRouterState<S, R, Auth>) -> Self {state.service.clone()}}+impl<S, R, Auth> FromRef<WebhookRouterState<S, R, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &WebhookRouterState<S, R, Auth>) -> Self {+ state.authorization_state.clone()+ }+}+/// Webhook path parameters.#[derive(Debug, serde::Deserialize)]pub struct WebhookPath {@@ -61,14 +78,16 @@ pub struct WebhookPath {}/// Per-user validation attempt rate limit.-pub struct PerUserValidateWebhookRateLimit {- user: MacroUserExtractor,+pub struct PerUserValidateWebhookRateLimit<Auth> {+ authorization: MacroAuthorizationExtractor<Auth>,webhook_id: WebhookId,}-impl<S> RateLimitExtractable<S> for PerUserValidateWebhookRateLimit+impl<S, Auth> RateLimitExtractable<S> for PerUserValidateWebhookRateLimit<Auth>where- S: Send + Sync,+ S: Send + Sync + 'static,+ Auth: MacroAuthorizationService,+ MacroAuthorizationState<Auth>: FromRef<S>,{fn config() -> RateLimitConfig {RateLimitConfig {@@ -79,15 +98,17 @@ wherefn key(&self) -> RateLimitKey {RateLimitKey::builder(&"per-user-validate-webhook")- .append(&self.user.macro_user_id.as_ref())+ .append(&self.authorization.macro_user_id.as_ref()).append(&self.webhook_id).finish()}}-impl<S> FromRequestParts<S> for PerUserValidateWebhookRateLimit+impl<S, Auth> FromRequestParts<S> for PerUserValidateWebhookRateLimit<Auth>where- S: Send + Sync,+ S: Send + Sync + 'static,+ Auth: MacroAuthorizationService,+ MacroAuthorizationState<Auth>: FromRef<S>,{type Rejection = Response;@@ -95,7 +116,7 @@ whereparts: &mut axum::http::request::Parts,state: &S,) -> Result<Self, Self::Rejection> {- let Cached(user): Cached<MacroUserExtractor> = parts+ let Cached(authorization): Cached<MacroAuthorizationExtractor<Auth>> = parts.extract_with_state(state).await.map_err(IntoResponse::into_response)?;@@ -105,34 +126,81 @@ where.map_err(IntoResponse::into_response)?;Ok(Self {- user,+ authorization,webhook_id: path.webhook_id,})}}+struct ValidateWebhookRateLimitState<R, Auth> {+ rate_limiter: R,+ authorization_state: MacroAuthorizationState<Auth>,+}++impl<R: Clone, Auth> Clone for ValidateWebhookRateLimitState<R, Auth> {+ fn clone(&self) -> Self {+ Self {+ rate_limiter: self.rate_limiter.clone(),+ authorization_state: self.authorization_state.clone(),+ }+ }+}++impl<R, Auth> FromRef<ValidateWebhookRateLimitState<R, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &ValidateWebhookRateLimitState<R, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++impl<R, Auth> RateLimitService for ValidateWebhookRateLimitState<R, Auth>+where+ R: RateLimitService,+ Auth: MacroAuthorizationService,+{+ async fn check_rate_limit(+ &self,+ key: RateLimitKey,+ config: RateLimitConfig,+ ) -> Result<RateLimitResult, Report> {+ self.rate_limiter.check_rate_limit(key, config).await+ }++ async fn rollback_ticket(&self, ticket: RateLimitOk) -> Result<(), Report> {+ self.rate_limiter.rollback_ticket(ticket).await+ }+}+/// Create a webhook API router.-pub fn webhook_router<S, R, T>(state: WebhookRouterState<S, R>) -> Router<T>+pub fn webhook_router<S, R, Auth, T>(state: WebhookRouterState<S, R, Auth>) -> Router<T>whereS: WebhookService,R: RateLimitService + Clone,- T: Send + Sync,+ Auth: MacroAuthorizationService,+ T: Send + Sync + 'static,{+ let rate_limit_state = ValidateWebhookRateLimitState {+ rate_limiter: state.rate_limiter.clone(),+ authorization_state: state.authorization_state.clone(),+ };let validate_route = Router::new().route("/webhooks/{webhook_id}/validate",- post(validate_webhook::<S>),+ post(validate_webhook::<S, Auth>),).layer(axum::middleware::from_fn_with_state(- state.rate_limiter.clone(),- rate_limit_middleware::<R, PerUserValidateWebhookRateLimit, R>,+ rate_limit_state,+ rate_limit_middleware::<+ ValidateWebhookRateLimitState<R, Auth>,+ PerUserValidateWebhookRateLimit<Auth>,+ ValidateWebhookRateLimitState<R, Auth>,+ >,));Router::new()- .route("/webhooks", post(create_webhook::<S>))+ .route("/webhooks", post(create_webhook::<S, Auth>)).route("/webhooks/{webhook_id}",- patch(patch_webhook::<S>).delete(delete_webhook::<S>),+ patch(patch_webhook::<S, Auth>).delete(delete_webhook::<S, Auth>),).merge(validate_route).with_state(state)@@ -151,12 +219,14 @@ where),tag = "webhook")]-pub async fn create_webhook<S: WebhookService>(+pub async fn create_webhook<S: WebhookService, Auth: MacroAuthorizationService>(State(service): State<Arc<S>>,- user: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<Auth>,Json(request): Json<CreateWebhookRequest>,) -> Result<(StatusCode, Json<CreateWebhookResponse>), WebhookHandlerError> {- let webhook = service.create_webhook(user.macro_user_id, request).await?;+ let webhook = service+ .create_webhook(authorization.macro_user_id, request)+ .await?;Ok((StatusCode::CREATED, Json(webhook.into())))}@@ -175,15 +245,15 @@ pub async fn create_webhook<S: WebhookService>(),tag = "webhook")]-pub async fn patch_webhook<S: WebhookService>(+pub async fn patch_webhook<S: WebhookService, Auth: MacroAuthorizationService>(State(service): State<Arc<S>>,- user: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<Auth>,Path(path): Path<WebhookPath>,Json(request): Json<PatchWebhookRequest>,) -> Result<Json<Webhook>, WebhookHandlerError> {Ok(Json(service- .patch_webhook(user.macro_user_id, path.webhook_id, request)+ .patch_webhook(authorization.macro_user_id, path.webhook_id, request).await?,))}@@ -201,13 +271,13 @@ pub async fn patch_webhook<S: WebhookService>(),tag = "webhook")]-pub async fn delete_webhook<S: WebhookService>(+pub async fn delete_webhook<S: WebhookService, Auth: MacroAuthorizationService>(State(service): State<Arc<S>>,- user: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<Auth>,Path(path): Path<WebhookPath>,) -> Result<StatusCode, WebhookHandlerError> {service- .delete_webhook(user.macro_user_id, path.webhook_id)+ .delete_webhook(authorization.macro_user_id, path.webhook_id).await?;Ok(StatusCode::NO_CONTENT)}@@ -226,14 +296,14 @@ pub async fn delete_webhook<S: WebhookService>(),tag = "webhook")]-pub async fn validate_webhook<S: WebhookService>(+pub async fn validate_webhook<S: WebhookService, Auth: MacroAuthorizationService>(State(service): State<Arc<S>>,- user: MacroUserExtractor,+ Cached(authorization): Cached<MacroAuthorizationExtractor<Auth>>,Path(path): Path<WebhookPath>,) -> Result<Json<ValidateWebhookResponse>, WebhookHandlerError> {Ok(Json(service- .validate_webhook(user.macro_user_id, path.webhook_id)+ .validate_webhook(authorization.macro_user_id, path.webhook_id).await?,))}diff --git a/crates/webhook/src/inbound/axum_router_test.rs b/crates/webhook/src/inbound/axum_router_test.rsindex 2892099c5f..eac1ac3554 100644--- a/crates/webhook/src/inbound/axum_router_test.rs+++ b/crates/webhook/src/inbound/axum_router_test.rs@@ -7,15 +7,25 @@ use crate::domain::{};use axum::{body::{Body, to_bytes},- http::{Request, StatusCode},+ http::{Request, StatusCode, header},+};+use macro_authorization::{+ InternalIdentityClaims, MacroAuthorizationError, MacroAuthorizationService,+ MacroAuthorizationState,};use macro_user_id::user_id::MacroUserIdStr;use model_user::UserContext;use rate_limit::{RateLimitConfig, RateLimitKey, RateLimitService};+use rootcause::Report;use serde_json::json;-use std::sync::{Arc, Mutex};+use std::sync::{+ Arc, Mutex,+ atomic::{AtomicUsize, Ordering},+};use tower::ServiceExt;+const VALID_INTERNAL_KEY: &str = "valid-internal-key";+#[derive(Clone, Default)]struct FakeService {calls: Arc<Mutex<Vec<ServiceCall>>>,@@ -58,6 +68,48 @@ impl Clone for ServiceCall {}}+#[derive(Clone, Default)]+struct FakeAuthorizationService {+ calls: Arc<AtomicUsize>,+}++impl FakeAuthorizationService {+ fn calls(&self) -> usize {+ self.calls.load(Ordering::SeqCst)+ }+}++impl MacroAuthorizationService for FakeAuthorizationService {+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {+ self.calls.fetch_add(1, Ordering::SeqCst);+ if jwt != "valid" {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }++ Ok(UserContext {+ user_id: user_id().to_string(),+ ..UserContext::default()+ })+ }++ async fn authorize_internal(+ &self,+ provided_key: &str,+ claims: InternalIdentityClaims,+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {+ if provided_key != VALID_INTERNAL_KEY {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }++ Ok(claims.user_id.map(|user_id| UserContext {+ user_id,+ fusion_user_id: claims.fusion_user_id.unwrap_or_default(),+ organization_id: claims.organization_id,+ permissions: None,+ }))+ }+}+impl WebhookService for FakeService {async fn create_webhook(&self,@@ -244,9 +296,12 @@ async fn patch_passes_authenticated_user_path_and_body_to_service() {async fn validate_passes_authenticated_user_and_path_to_service() {let service = FakeService::default();let limiter = FakeRateLimiter::default();- let response = send(+ let authorization = FakeAuthorizationService::default();+ let response = send_request(service.clone(),limiter.clone(),+ authorization.clone(),+ Some("Bearer valid"),"POST","/webhooks/wh_123/validate",json!({}),@@ -254,6 +309,7 @@ async fn validate_passes_authenticated_user_and_path_to_service() {.await;assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(authorization.calls(), 1);assert_eq!(limiter.checks(), 1);match &service.calls()[0] {ServiceCall::Validate(user, webhook_id) => {@@ -309,7 +365,27 @@ async fn validation_rate_limit_exceeded_maps_to_429_and_skips_service() {}#[tokio::test]-async fn create_and_patch_are_not_rate_limited() {+async fn missing_credentials_are_rejected_before_rate_limit_and_service_calls() {+ let service = FakeService::default();+ let limiter = FakeRateLimiter::default();+ let response = send_request(+ service.clone(),+ limiter.clone(),+ FakeAuthorizationService::default(),+ None,+ "POST",+ "/webhooks/wh_123/validate",+ json!({}),+ )+ .await;++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(limiter.checks(), 0);+ assert!(service.calls().is_empty());+}++#[tokio::test]+async fn create_patch_and_delete_are_not_rate_limited() {let service = FakeService::default();let limiter = FakeRateLimiter::exceeded();@@ -322,16 +398,25 @@ async fn create_and_patch_are_not_rate_limited() {).await;let patch_response = send(- service,+ service.clone(),limiter.clone(),"PATCH","/webhooks/wh_123",json!({"name":"Renamed"}),).await;+ let delete_response = send(+ service,+ limiter.clone(),+ "DELETE",+ "/webhooks/wh_123",+ json!({}),+ )+ .await;assert_eq!(create_response.status(), StatusCode::CREATED);assert_eq!(patch_response.status(), StatusCode::OK);+ assert_eq!(delete_response.status(), StatusCode::NO_CONTENT);assert_eq!(limiter.checks(), 0);}@@ -378,20 +463,44 @@ async fn send(uri: &str,body: serde_json::Value,) -> axum::response::Response {- let router = webhook_router::<_, _, ()>(WebhookRouterState::new(service, limiter));+ send_request(+ service,+ limiter,+ FakeAuthorizationService::default(),+ Some("Bearer valid"),+ method,+ uri,+ body,+ )+ .await+}++async fn send_request(+ service: FakeService,+ limiter: FakeRateLimiter,+ authorization: FakeAuthorizationService,+ authorization_header: Option<&str>,+ method: &str,+ uri: &str,+ body: serde_json::Value,+) -> axum::response::Response {+ let authorization_state = MacroAuthorizationState::new(Arc::new(authorization));+ let router = webhook_router::<_, _, _, ()>(WebhookRouterState::new(+ service,+ limiter,+ authorization_state,+ ));+ let request = Request::builder()+ .method(method)+ .uri(uri)+ .header("content-type", "application/json");+ let request = match authorization_header {+ Some(value) => request.header(header::AUTHORIZATION, value),+ None => request,+ };+router- .oneshot(- Request::builder()- .method(method)- .uri(uri)- .extension(UserContext {- user_id: user_id().to_string(),- ..UserContext::default()- })- .header("content-type", "application/json")- .body(Body::from(body.to_string()))- .unwrap(),- )+ .oneshot(request.body(Body::from(body.to_string())).unwrap()).await.unwrap()}diff --git a/services/authentication_service/Cargo.toml b/services/authentication_service/Cargo.tomlindex 26b1b43b90..4dc61cc7ca 100644--- a/services/authentication_service/Cargo.toml+++ b/services/authentication_service/Cargo.toml@@ -43,6 +43,7 @@ base64 = { workspace = true }chrono = { workspace = true }comms_db_client = { path = "../../crates/comms_db_client" }cookie = { workspace = true }+decode_jwt = { path = "../../crates/decode_jwt" }document_storage_service_client = { path = "../../crates/document_storage_service_client" }email = { path = "../../crates/email", features = ["http_client"] }doppleganger = { workspace = true }@@ -63,6 +64,7 @@ jsonwebtoken = { workspace = true }last_online_tracker = { path = "../../crates/last_online_tracker" }loops_client = { path = "../../crates/loops_client" }macro_auth = { path = "../../crates/macro_auth" }+macro_authorization = { path = "../../crates/macro_authorization" }macro_aws_config = { path = "../../crates/macro_aws_config" }macro_cache_client = { path = "../../crates/macro_cache_client", default-features = false, features = ["auth",@@ -82,9 +84,7 @@ macro_env = { path = "../../crates/macro_env" }macro_env_var = { path = "../../crates/macro_env_var" }macro_queues = { path = "../../crates/macro_queues" }macro_middleware = { path = "../../crates/macro_middleware", default-features = false, features = [- "auth","tracking",- "user_permissions",] }macro_service_urls = { path = "../../crates/macro_service_urls" }macro_tower_layers = { path = "../../crates/macro_tower_layers" }@@ -97,8 +97,6 @@ mockall = { workspace = true }model = { path = "../../crates/model" }model-entity = { path = "../../crates/model-entity" }model_notifications = { path = "../../crates/model_notifications" }-model_user = { path = "../../crates/model_user", features = ["axum"] }-models_team = { path = "../../crates/models_team" }native_app_service = { path = "../../crates/native_app_service" }non_empty = { path = "../../crates/non_empty" }notification = { path = "../../crates/notification" }diff --git a/services/authentication_service/src/api/context.rs b/services/authentication_service/src/api/context.rsindex d8967bae56..b88d47dd64 100644--- a/services/authentication_service/src/api/context.rs+++ b/services/authentication_service/src/api/context.rs@@ -12,6 +12,9 @@ use github::outbound::github_oauth_client::GithubOauthImpl;use github::outbound::pg_github_repo::PgGithubRepo;use loops_client::LoopsClient;use macro_auth::{InternalApiKey, middleware::decode_jwt::JwtValidationArgs};+use macro_authorization::{+ MacroAuthJwtValidator, MacroAuthorizationServiceImpl, MacroAuthorizationState,+};use macro_cache_client::MacroCache;use macro_env::Environment;use macro_env_var::env_var;@@ -44,7 +47,7 @@ pub(crate) type TeamsServiceType = teams::domain::team_service::TeamServiceImpl<teams::outbound::team_analytics::AnalyticsClientTeamAnalytics,>;-type RateLimiter = RateLimitServiceImpl<RedisRateLimitAdapter<redis::Client>>;+pub(crate) type RateLimiter = RateLimitServiceImpl<RedisRateLimitAdapter<redis::Client>>;pub(crate) type ReferralServiceType = ReferralServiceImpl<PgReferralRepo,@@ -61,6 +64,8 @@ pub(crate) type GithubLinkServiceType = GithubLinkServiceImpl<pub(crate) type EntityAccessServiceType = EntityAccessServiceImpl<PgAccessRepository>;+pub(crate) type AuthorizationService = MacroAuthorizationServiceImpl<MacroAuthJwtValidator>;+#[derive(Clone, FromRef)]pub(crate) struct ApiContext {pub db: PgPool,@@ -76,6 +81,7 @@ pub(crate) struct ApiContext {pub sqs_client: Arc<sqs_client::SQS>,pub environment: Environment,pub jwt_args: JwtValidationArgs,+ pub authorization_state: MacroAuthorizationState<AuthorizationService>,pub token_context: MacroApiTokenContext,pub internal_api_key: InternalApiKey,pub stripe_webhook_secret: LocalOrRemoteSecret<StripeWebhookSecretKey>,diff --git a/services/authentication_service/src/api/email/generate_email_link.rs b/services/authentication_service/src/api/email/generate_email_link.rsindex 8fafd79fc9..2e42af0e8c 100644--- a/services/authentication_service/src/api/email/generate_email_link.rs+++ b/services/authentication_service/src/api/email/generate_email_link.rs@@ -1,20 +1,22 @@use anyhow::Context;use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;use utoipa::ToSchema;-use crate::{api::context::ApiContext, config::BASE_URL, rate_limit_config::RATE_LIMIT_CONFIG};--use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,+use crate::{+ api::context::{ApiContext, AuthorizationService},+ config::BASE_URL,+ rate_limit_config::RATE_LIMIT_CONFIG,};+use model::response::{EmptyResponse, ErrorResponse};+#[derive(serde::Deserialize, serde::Serialize, ToSchema)]pub struct GenerateEmailLinkRequest {/// The email address to resend the verification email to@@ -34,14 +36,15 @@ static VERIFY_EMAIL_TEMPLATE: &str = include_str!("./_verify_email_template.html(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context, ip_context,req), fields(client_ip=%ip_context, email=%req.email, fusion_user_id=%user_context.fusion_user_id), err(Debug))]+#[tracing::instrument(skip(ctx, authorization, ip_context,req), fields(client_ip=%ip_context, email=%req.email, fusion_user_id=%authorization.user_context.fusion_user_id), err(Debug))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,ip_context: ClientIp,extract::Json(mut req): extract::Json<GenerateEmailLinkRequest>,) -> Result<Response, Response> {tracing::info!("generate_email_link");+ let user_context = &authorization.user_context;// normalize the email before linkingreq.email = email_validator::normalize_email(&req.email).context("failed to normalize email")diff --git a/services/authentication_service/src/api/email/mod.rs b/services/authentication_service/src/api/email/mod.rsindex dc59be0293..caa515559b 100644--- a/services/authentication_service/src/api/email/mod.rs+++ b/services/authentication_service/src/api/email/mod.rs@@ -1,11 +1,8 @@+use crate::api::context::ApiContext;use axum::{Router,routing::{get, post},};-use macro_auth::middleware::decode_jwt::JwtValidationArgs;-use tower::ServiceBuilder;--use crate::api::context::ApiContext;pub(in crate::api) mod generate_email_link;pub(in crate::api) mod resend_fusionauth_verify_user_email;@@ -13,7 +10,7 @@ pub(in crate::api) mod verify_email_link;pub(in crate::api) mod verify_fusionauth_user_email;#[allow(dead_code)]-pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {+pub fn router() -> Router<ApiContext> {Router::new().route("/verify/fusionauth/{verification_id}",@@ -24,16 +21,9 @@ pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {post(resend_fusionauth_verify_user_email::handler),).route("/verify/{verification_id}", get(verify_email_link::handler))- .merge(router_with_auth(jwt_args))+ .merge(router_with_auth())}-fn router_with_auth(jwt_args: JwtValidationArgs) -> Router<ApiContext> {- Router::new()- .route("/generate/link", post(generate_email_link::handler))- .layer(- ServiceBuilder::new().layer(axum::middleware::from_fn_with_state(- jwt_args,- macro_middleware::auth::decode_jwt::handler,- )),- )+fn router_with_auth() -> Router<ApiContext> {+ Router::new().route("/generate/link", post(generate_email_link::handler))}diff --git a/services/authentication_service/src/api/github_pull_requests.rs b/services/authentication_service/src/api/github_pull_requests.rsindex 33e197ed9c..58964ecf78 100644--- a/services/authentication_service/src/api/github_pull_requests.rs+++ b/services/authentication_service/src/api/github_pull_requests.rs@@ -9,10 +9,10 @@ use github::domain::{models::{EnrichGithubPullRequestsProxyRequest, EnrichGithubPullRequestsResponse, GithubError},ports::GithubLinkService,};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};#[derive(thiserror::Error, Debug)]pub enum EnrichGithubPullRequestsProxyError {@@ -64,17 +64,17 @@ pub fn router() -> Router<ApiContext> {(status = 500, body = ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, request), fields(user_id = %user_context.macro_user_id), err)]+#[tracing::instrument(skip(ctx, authorization, request), fields(user_id = %authorization.macro_user_id), err)]pub async fn handler(State(ctx): State<ApiContext>,- user_context: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(request): extract::Json<EnrichGithubPullRequestsProxyRequest>,) -> Result<Json<EnrichGithubPullRequestsResponse>, EnrichGithubPullRequestsProxyError> {tracing::info!("enrich_github_pull_requests");let pull_requests = ctx.github_link_service- .enrich_pull_requests(&user_context.macro_user_id, request.pull_requests)+ .enrich_pull_requests(&authorization.macro_user_id, request.pull_requests).await?;Ok(Json(EnrichGithubPullRequestsResponse { pull_requests }))diff --git a/services/authentication_service/src/api/internal/delete_inbox_grant_user.rs b/services/authentication_service/src/api/internal/delete_inbox_grant_user.rsindex 3f73495914..d5d3f1d5f0 100644--- a/services/authentication_service/src/api/internal/delete_inbox_grant_user.rs+++ b/services/authentication_service/src/api/internal/delete_inbox_grant_user.rs@@ -5,10 +5,10 @@ use axum::{response::{IntoResponse, Response},};use fusionauth::error::FusionAuthClientError;-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};#[derive(serde::Deserialize, Debug)]pub struct DeleteInboxGrantUserQueryParams {@@ -22,10 +22,10 @@ pub struct DeleteInboxGrantUserQueryParams {/// Refuses to delete an **active** user: relocated mailbox stubs are always deactivated,/// while real accounts are active, so the state doubles as a guard against a caller bug/// pointing this at a human's account. Idempotent on an already-deleted user.-#[tracing::instrument(skip(ctx, _valid_access))]+#[tracing::instrument(skip(ctx, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _valid_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Query(DeleteInboxGrantUserQueryParams { fusionauth_user_id }): extract::Query<DeleteInboxGrantUserQueryParams,>,diff --git a/services/authentication_service/src/api/internal/google_access_token.rs b/services/authentication_service/src/api/internal/google_access_token.rsindex 509766bc92..473745a51b 100644--- a/services/authentication_service/src/api/internal/google_access_token.rs+++ b/services/authentication_service/src/api/internal/google_access_token.rs@@ -6,11 +6,13 @@ use axum::{};use fusionauth::FusionAuthClient;use fusionauth::error::FusionAuthClientError;-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use model::authentication::google_token::GoogleAccessToken;use model::response::ErrorResponse;use std::sync::Arc;+use crate::api::context::AuthorizationService;+#[derive(serde::Deserialize, Debug)]pub struct GoogleAccessTokenParams {fusionauth_user_id: String,@@ -21,10 +23,10 @@ pub struct GoogleAccessTokenParams {}/// Gets link between user and identity provider-#[tracing::instrument(skip(auth_client, _internal_access))]+#[tracing::instrument(skip(auth_client, _internal_authorization))]pub async fn handler(State(auth_client): State<Arc<FusionAuthClient>>,- _internal_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Query(params): extract::Query<GoogleAccessTokenParams>,) -> Result<Response, Response> {get_access_token(auth_client, ¶ms, "google_gmail").awaitdiff --git a/services/authentication_service/src/api/internal/post_get_existing_users.rs b/services/authentication_service/src/api/internal/post_get_existing_users.rsindex 946afc3840..727cdb478c 100644--- a/services/authentication_service/src/api/internal/post_get_existing_users.rs+++ b/services/authentication_service/src/api/internal/post_get_existing_users.rs@@ -1,4 +1,4 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::{Json,@@ -6,7 +6,7 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use macro_user_id::{cowlike::CowLike, lowercased::Lowercase, user_id::MacroUserId};use model::response::ErrorResponse;use utoipa::ToSchema;@@ -62,10 +62,10 @@ impl IntoResponse for GetExistingUsersError {(status = 500, body = ErrorResponse),),)]-#[tracing::instrument(skip(ctx, _valid_access))]+#[tracing::instrument(skip(ctx, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _valid_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(GetExistingUsersRequest { user_ids }): extract::Json<GetExistingUsersRequest>,) -> Result<Json<GetExistingUsersResponse>, GetExistingUsersError> {tracing::info!("internal_get_existing_users");diff --git a/services/authentication_service/src/api/internal/relocate_inbox_grant.rs b/services/authentication_service/src/api/internal/relocate_inbox_grant.rsindex 864b48d358..38da172906 100644--- a/services/authentication_service/src/api/internal/relocate_inbox_grant.rs+++ b/services/authentication_service/src/api/internal/relocate_inbox_grant.rs@@ -8,10 +8,10 @@ use axum::{response::{IntoResponse, Response},};use fusionauth::identity_provider::{IdentityProviderLink, LinkUserRequest};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};const GMAIL_IDP_NAME: &str = "google_gmail";@@ -47,10 +47,10 @@ pub struct RelocateInboxGrantResponse {/// password reset all resolve to it by email/identity. Links are only ever created while/// the user is active, so an existing deactivated stub is reactivated for the duration/// of the relink and deactivated again afterwards.-#[tracing::instrument(skip(ctx, _valid_access))]+#[tracing::instrument(skip(ctx, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _valid_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(RelocateInboxGrantRequest {email,owner_fusionauth_user_id,diff --git a/services/authentication_service/src/api/internal/remove_link.rs b/services/authentication_service/src/api/internal/remove_link.rsindex 0ef93b2fae..f4ce8973a5 100644--- a/services/authentication_service/src/api/internal/remove_link.rs+++ b/services/authentication_service/src/api/internal/remove_link.rs@@ -1,4 +1,4 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use fusionauth::error::FusionAuthClientError;use fusionauth::identity_provider::Link;@@ -8,7 +8,7 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};#[cfg(test)]@@ -41,10 +41,10 @@ fn find_idp_link(links: Vec<Link>, linked_email: &str) -> Option<Link> {(status = 500, body = ErrorResponse),),)]-#[tracing::instrument(skip(ctx, _valid_access))]+#[tracing::instrument(skip(ctx, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _valid_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Query(RemoveLinkQueryParams {fusionauth_user_id,linked_email,diff --git a/services/authentication_service/src/api/jwt/macro_api_token.rs b/services/authentication_service/src/api/jwt/macro_api_token.rsindex 401f7bdec8..7cdf91d7cd 100644--- a/services/authentication_service/src/api/jwt/macro_api_token.rs+++ b/services/authentication_service/src/api/jwt/macro_api_token.rs@@ -1,12 +1,12 @@-use crate::api::context::MacroApiTokenContext;+use crate::api::context::{AuthorizationService, MacroApiTokenContext};use axum::{- Extension, Json,+ Json,extract::{Query, State},http::StatusCode,response::{IntoResponse, Response},};use macro_auth::macro_api_token::EncodeMacroApiTokenArgs;-use model::user::UserContext;+use macro_authorization::MacroAuthorizationExtractor;use sqlx::PgPool;use utoipa::ToSchema;@@ -40,13 +40,14 @@ pub struct MacroApiTokenQuery {(status = 500, body=String),))]-#[tracing::instrument(skip(db, macro_api_token_context, user_context))]+#[tracing::instrument(skip(db, macro_api_token_context, authorization))]pub async fn handler(State(db): State<PgPool>,State(macro_api_token_context): State<MacroApiTokenContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Query(query): Query<MacroApiTokenQuery>,) -> Result<Response, Response> {+ let user_context = &authorization.user_context;let email = if let Some(email) = query.email.clone() {// TODO: figure out if email is url_encoded by defaultlet email = urlencoding::decode(email.as_ref()).map_err(|e| {diff --git a/services/authentication_service/src/api/jwt/mod.rs b/services/authentication_service/src/api/jwt/mod.rsindex 0c42a64d22..1017c7f39b 100644--- a/services/authentication_service/src/api/jwt/mod.rs+++ b/services/authentication_service/src/api/jwt/mod.rs@@ -2,7 +2,6 @@ use axum::{Router,routing::{get, post},};-use macro_auth::middleware::decode_jwt::JwtValidationArgs;use tower::ServiceBuilder;use tower_cookies::CookieManagerLayer;@@ -14,7 +13,7 @@ use super::middleware;pub(in crate::api) mod macro_api_token;pub(in crate::api) mod refresh;-pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {+pub fn router() -> Router<ApiContext> {Router::new().route("/refresh",@@ -26,14 +25,5 @@ pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {.layer(CookieManagerLayer::new()),),)- .route(- "/macro_api_token",- get(macro_api_token::handler).layer(ServiceBuilder::new().layer(- axum::middleware::from_fn_with_state(- jwt_args,- macro_middleware::auth::decode_jwt::handler, // Decodes the JWT to create- // user context- ),- )),- )+ .route("/macro_api_token", get(macro_api_token::handler))}diff --git a/services/authentication_service/src/api/jwt_session.rs b/services/authentication_service/src/api/jwt_session.rsnew file mode 100644index 0000000000..52d1972889--- /dev/null+++ b/services/authentication_service/src/api/jwt_session.rs@@ -0,0 +1,50 @@+use std::convert::Infallible;++use axum::{+ extract::{FromRef, FromRequestParts, Query},+ http::request::Parts,+};+use decode_jwt::{DecodedJwt, JwtContext, Params};+use macro_auth::{headers::AccessTokenExtractor, middleware::decode_jwt::JwtValidationArgs};+#[allow(deprecated)]+use macro_authorization::{INTERNAL_API_KEY_HEADER, LEGACY_DSS_INTERNAL_API_KEY_HEADER};++/// The FusionAuth session associated with an authorized request, when present.+///+/// This extractor must follow the primary authorization extractor in handler+/// arguments. Authorization rejects invalid credentials before session decoding+/// errors are treated as an absent FusionAuth session here.+pub(crate) struct JwtSessionContext(pub(crate) Option<JwtContext>);++impl<S> FromRequestParts<S> for JwtSessionContext+where+ S: Send + Sync,+ JwtValidationArgs: FromRef<S>,+{+ type Rejection = Infallible;++ async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {+ if is_internal_request(parts) {+ return Ok(Self(None));+ }++ let access_token = AccessTokenExtractor::from_request_parts(parts, state).await;+ let Ok(Query(params)) = Query::<Params>::from_request_parts(parts, state).await else {+ return Ok(Self(None));+ };+ let jwt_args = JwtValidationArgs::from_ref(state);+ let jwt_context = DecodedJwt::new(access_token, params, &jwt_args)+ .ok()+ .and_then(|decoded| decoded.jwt_context);++ Ok(Self(jwt_context))+ }+}++#[allow(deprecated)]+fn is_internal_request(parts: &Parts) -> bool {+ parts.headers.contains_key(INTERNAL_API_KEY_HEADER)+ || parts+ .headers+ .contains_key(LEGACY_DSS_INTERNAL_API_KEY_HEADER)+}diff --git a/services/authentication_service/src/api/link/create_in_progress_link.rs b/services/authentication_service/src/api/link/create_in_progress_link.rsindex 63a9ed2e54..5599e58596 100644--- a/services/authentication_service/src/api/link/create_in_progress_link.rs+++ b/services/authentication_service/src/api/link/create_in_progress_link.rs@@ -1,14 +1,14 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;+use model::response::ErrorResponse;-use crate::api::context::ApiContext;--use model::{response::ErrorResponse, user::UserContext};+use crate::api::context::{ApiContext, AuthorizationService};#[derive(serde::Deserialize, serde::Serialize, Debug, utoipa::ToSchema)]pub struct CreateInProgressLinkResponse {@@ -29,18 +29,18 @@ pub struct CreateInProgressLinkResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context), fields(client_ip=%ip_context, user_id=%user_context.user_id, fusion_user_id=%user_context.fusion_user_id), err(Debug))]+#[tracing::instrument(skip(ctx, ip_context, authorization), fields(client_ip=%ip_context, user_id=%authorization.user_context.user_id, fusion_user_id=%authorization.user_context.fusion_user_id), err(Debug))]pub async fn handler(State(ctx): State<ApiContext>,ip_context: ClientIp,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {tracing::info!("create_in_progress_link");let count =macro_db_client::in_progress_user_link::count_existing_in_progress_user_links_for_user(&ctx.db,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await.map_err(|e| {@@ -65,7 +65,7 @@ pub async fn handler(let link_id = macro_db_client::in_progress_user_link::create_in_progress_user_link(&ctx.db,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await.map_err(|e| {diff --git a/services/authentication_service/src/api/link/github.rs b/services/authentication_service/src/api/link/github.rsindex c7051ce82e..aae211bd64 100644--- a/services/authentication_service/src/api/link/github.rs+++ b/services/authentication_service/src/api/link/github.rs@@ -5,14 +5,16 @@ use axum::{response::{IntoResponse, Response},};use github::domain::{models::GithubError, ports::GithubLinkService};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;-use model_user::axum_extractor::MacroUserExtractor;+use model::response::{EmptyResponse, ErrorResponse};use serde_utils::urlencode::UrlEncoded;use url::Url;-use crate::api::{context::ApiContext, oauth2::OAuthState};--use model::response::{EmptyResponse, ErrorResponse};+use crate::api::{+ context::{ApiContext, AuthorizationService},+ oauth2::OAuthState,+};pub const REAUTHENTICATION_REQUIRED_MESSAGE: &str = "ReauthenticationRequired";@@ -116,14 +118,14 @@ impl IntoResponse for GithubLinkStatusError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context), fields(client_ip=%ip_context, user_id=%user_context.macro_user_id), err)]+#[tracing::instrument(skip(ctx, ip_context, authorization), fields(client_ip=%ip_context, user_id=%authorization.macro_user_id), err)]pub async fn check_github_link_status_handler(State(ctx): State<ApiContext>,ip_context: ClientIp,- user_context: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Json<GithubLinkStatusResponse>, GithubLinkStatusError> {ctx.github_link_service- .check_user_link_token(&user_context.macro_user_id)+ .check_user_link_token(&authorization.macro_user_id).await?;Ok(Json(GithubLinkStatusResponse {@@ -154,12 +156,12 @@ pub(crate) struct InitGithubLinkQueryParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context), fields(client_ip=%ip_context, user_id=%user_context.user_context.user_id, fusion_user_id=%user_context.user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, ip_context, authorization), fields(client_ip=%ip_context, user_id=%authorization.user_context.user_id, fusion_user_id=%authorization.user_context.fusion_user_id), err)]pub async fn init_github_link_handler(State(ctx): State<ApiContext>,query: Query<InitGithubLinkQueryParams>,ip_context: ClientIp,- user_context: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Json<InitGithubLinkResponse>, InitGithubLinkError> {let Query(InitGithubLinkQueryParams { original_url }) = query;// TODO: this should probably be a middleware or extractor@@ -167,7 +169,7 @@ pub async fn init_github_link_handler(let count =macro_db_client::in_progress_user_link::count_existing_in_progress_user_links_for_user(&ctx.db,- &user_context.user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await?;@@ -178,7 +180,7 @@ pub async fn init_github_link_handler(// Create in-progress linklet link_id = macro_db_client::in_progress_user_link::create_in_progress_user_link(&ctx.db,- &user_context.user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await?;@@ -252,14 +254,14 @@ impl IntoResponse for DeleteGithubLinkError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context), fields(client_ip=%ip_context, user_id=%user_context.macro_user_id), err)]+#[tracing::instrument(skip(ctx, ip_context, authorization), fields(client_ip=%ip_context, user_id=%authorization.macro_user_id), err)]pub async fn delete_github_link_handler(State(ctx): State<ApiContext>,ip_context: ClientIp,- user_context: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Json<EmptyResponse>, DeleteGithubLinkError> {ctx.github_link_service- .delete_user_link(&user_context.macro_user_id)+ .delete_user_link(&authorization.macro_user_id).await?;Ok(Json(EmptyResponse::default()))diff --git a/services/authentication_service/src/api/link/gmail.rs b/services/authentication_service/src/api/link/gmail.rsindex 30930cb2e8..d18e5c18ae 100644--- a/services/authentication_service/src/api/link/gmail.rs+++ b/services/authentication_service/src/api/link/gmail.rs@@ -5,17 +5,19 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;-use macro_middleware::user_permissions::attach_user_permissions::PermissionsExtractor;use macro_user_id::user_id::MacroUserIdStr;use model::response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use roles_and_permissions::domain::model::PermissionId;use serde_utils::urlencode::UrlEncoded;use url::Url;use crate::api::{- context::ApiContext, link::github::REAUTHENTICATION_REQUIRED_MESSAGE, oauth2::OAuthState,+ context::{ApiContext, AuthorizationService},+ link::github::REAUTHENTICATION_REQUIRED_MESSAGE,+ oauth2::OAuthState,+ permissions_extractor::DbPermissionsExtractor,};#[cfg(test)]@@ -96,26 +98,28 @@ pub(crate) struct InitGmailLinkQueryParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context, permissions), fields(client_ip=%ip_context, user_id=%user_context.user_context.user_id, fusion_user_id=%user_context.user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, ip_context, db_permissions), fields(client_ip=%ip_context, user_id=%db_permissions.authorization.user_context.user_id, fusion_user_id=%db_permissions.authorization.user_context.fusion_user_id), err)]pub async fn init_gmail_link_handler(State(ctx): State<ApiContext>,query: Query<InitGmailLinkQueryParams>,ip_context: ClientIp,- user_context: MacroUserExtractor,- PermissionsExtractor(permissions): PermissionsExtractor,+ db_permissions: DbPermissionsExtractor,) -> Result<Json<InitGmailLinkResponse>, InitGmailLinkError> {let Query(InitGmailLinkQueryParams { original_url }) = query;+ let authorization = &db_permissions.authorization;enforce_inbox_paywall(- permissions.contains(&PermissionId::ReadProfessionalFeatures.to_string()),- || count_accessible_email_inboxes(&ctx.db, &user_context.macro_user_id),+ db_permissions+ .permissions+ .contains(&PermissionId::ReadProfessionalFeatures.to_string()),+ || count_accessible_email_inboxes(&ctx.db, &authorization.macro_user_id),).await?;let count =macro_db_client::in_progress_user_link::count_existing_in_progress_user_links_for_user(&ctx.db,- &user_context.user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await?;@@ -125,7 +129,7 @@ pub async fn init_gmail_link_handler(let link_id = macro_db_client::in_progress_user_link::create_in_progress_user_link(&ctx.db,- &user_context.user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await?;@@ -240,20 +244,20 @@ impl IntoResponse for GmailLinkStatusError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, ip_context, user_context), fields(client_ip=%ip_context, user_id=%user_context.macro_user_id), err)]+#[tracing::instrument(skip(ctx, ip_context, authorization), fields(client_ip=%ip_context, user_id=%authorization.macro_user_id), err)]pub async fn check_gmail_link_status_handler(State(ctx): State<ApiContext>,ip_context: ClientIp,- user_context: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Json<GmailLinkStatusResponse>, GmailLinkStatusError> {// Check if the user has an email link in db- if macro_db_client::email::check_user_email_link(&ctx.db, &user_context.macro_user_id)+ if macro_db_client::email::check_user_email_link(&ctx.db, &authorization.macro_user_id).await.map_err(GmailLinkStatusError::Internal)?{let links = ctx.auth_client- .get_links(&user_context.user_context.fusion_user_id, None)+ .get_links(&authorization.user_context.fusion_user_id, None).await.map_err(|e| GmailLinkStatusError::Internal(e.into()))?;diff --git a/services/authentication_service/src/api/link/mod.rs b/services/authentication_service/src/api/link/mod.rsindex 592b123575..df22aa4fb3 100644--- a/services/authentication_service/src/api/link/mod.rs+++ b/services/authentication_service/src/api/link/mod.rs@@ -7,9 +7,8 @@ pub(in crate::api) mod create_in_progress_link;pub(in crate::api) mod github;pub(in crate::api) mod gmail;-/// The link router-/// We ensure the user is logged in with the `macro_middleware::auth::decode_jwt::handler`.-pub fn router(_state: ApiContext) -> Router<ApiContext> {+/// Routes for authenticated account-link operations.+pub fn router() -> Router<ApiContext> {Router::new().route("/", post(create_in_progress_link::handler)).route("/github", post(github::init_github_link_handler))diff --git a/services/authentication_service/src/api/logout.rs b/services/authentication_service/src/api/logout.rsindex f3baa8a653..32a8be27fc 100644--- a/services/authentication_service/src/api/logout.rs+++ b/services/authentication_service/src/api/logout.rs@@ -1,31 +1,24 @@-use super::context::ApiContext;+use super::{+ context::{ApiContext, AuthorizationService},+ jwt_session::JwtSessionContext,+};use crate::api::utils::{create_access_token_cookie, create_refresh_token_cookie};use axum::{- Extension, Json, Router,+ Json, Router,extract::State,http::StatusCode,response::{IntoResponse, Response},routing::{get, post},};-use macro_auth::middleware::decode_jwt::JwtValidationArgs;-use macro_middleware::auth::decode_jwt::JwtContext;+use macro_authorization::MacroAuthorizationExtractor;use model::response::EmptyResponse;-use model::user::UserContext;-use tower::ServiceBuilder;use tower_cookies::{CookieManagerLayer, Cookies};-pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {+pub fn router() -> Router<ApiContext> {Router::new().route("/", post(handler)).route("/", get(handler))- .layer(- ServiceBuilder::new()- .layer(CookieManagerLayer::new())- .layer(axum::middleware::from_fn_with_state(- jwt_args,- macro_middleware::auth::decode_jwt::handler,- )),- )+ .layer(CookieManagerLayer::new())}/// Initiates a passwordless login@@ -37,11 +30,11 @@ pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {(status = 200, body= EmptyResponse),))]-#[tracing::instrument(skip(ctx, user_context, jwt_context, cookies), fields(user_id=%user_context.user_id, organization_id=?user_context.organization_id, audience=%jwt_context.audience, tid=%jwt_context.tid))]+#[tracing::instrument(skip(ctx, authorization, jwt_session, cookies), fields(user_id=%authorization.user_context.user_id, organization_id=?authorization.user_context.organization_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,- jwt_context: Extension<JwtContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,+ JwtSessionContext(jwt_session): JwtSessionContext,cookies: Cookies,) -> Result<Response, Response> {// Remove access token cookie@@ -54,9 +47,11 @@ pub async fn handler(refresh_token_cookie.set_expires(Some(time::OffsetDateTime::now_utc()));cookies.add(refresh_token_cookie);- // Logout of fusionauth- if let Err(e) = ctx.auth_client.logout(&jwt_context.tid).await {- tracing::warn!(error=%e, "error logging out");+ // Logout of fusionauth when the request used a FusionAuth session.+ if let Some(jwt_context) = jwt_session+ && let Err(e) = ctx.auth_client.logout(&jwt_context.tid).await+ {+ tracing::warn!(error=?e, "error logging out");}Ok((StatusCode::OK, Json(EmptyResponse::default())).into_response())diff --git a/services/authentication_service/src/api/merge/create_merge_request.rs b/services/authentication_service/src/api/merge/create_merge_request.rsindex 458692f066..5dbd2024ec 100644--- a/services/authentication_service/src/api/merge/create_merge_request.rs+++ b/services/authentication_service/src/api/merge/create_merge_request.rs@@ -1,20 +1,21 @@use anyhow::Context;use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;use utoipa::ToSchema;-use crate::{api::context::ApiContext, rate_limit_config::RATE_LIMIT_CONFIG};--use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,+use crate::{+ api::context::{ApiContext, AuthorizationService},+ rate_limit_config::RATE_LIMIT_CONFIG,};+use model::response::{EmptyResponse, ErrorResponse};+#[derive(serde::Deserialize, serde::Serialize, ToSchema)]pub struct CreateAccountMergeRequest {/// The email address to generate the merge link for.@@ -39,14 +40,15 @@ static MERGE_REQUEST_TEMPLATE: &str = include_str!("./_merge_request_template.ht(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context, ip_context,req), fields(client_ip=%ip_context, email=%req.email, fusion_user_id=%user_context.fusion_user_id), err(Debug))]+#[tracing::instrument(skip(ctx, authorization, ip_context,req), fields(client_ip=%ip_context, email=%req.email, fusion_user_id=%authorization.user_context.fusion_user_id), err(Debug))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,ip_context: ClientIp,extract::Json(mut req): extract::Json<CreateAccountMergeRequest>,) -> Result<Response, Response> {tracing::info!("create_merge_request");+ let user_context = &authorization.user_context;// normalize the emailreq.email = email_validator::normalize_email(&req.email)diff --git a/services/authentication_service/src/api/merge/verify_merge_request.rs b/services/authentication_service/src/api/merge/verify_merge_request.rsindex ac766fa8a2..a4e02e1e00 100644--- a/services/authentication_service/src/api/merge/verify_merge_request.rs+++ b/services/authentication_service/src/api/merge/verify_merge_request.rs@@ -1,20 +1,18 @@use std::borrow::Cow;use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_middleware::tracking::ClientIp;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use fusionauth::identity_provider::{IdentityProviderLink, LinkUserRequest};-use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,-};+use model::response::{EmptyResponse, ErrorResponse};#[derive(serde::Deserialize)]pub struct Params {@@ -35,14 +33,15 @@ pub struct Params {(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context, ip_context), fields(client_ip=%ip_context, fusion_user_id=%user_context.fusion_user_id), err(Debug))]+#[tracing::instrument(skip(ctx, authorization, ip_context), fields(client_ip=%ip_context, fusion_user_id=%authorization.user_context.fusion_user_id), err(Debug))]pub async fn handler(State(ctx): State<ApiContext>,ip_context: ClientIp,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Path(Params { code }): extract::Path<Params>,) -> Result<Response, Response> {tracing::info!("verify_merge_request");+ let user_context = &authorization.user_context;let (account_merge_request_id, to_merge_macro_user_id) =macro_db_client::account_merge_request::get_merge_request_info(diff --git a/services/authentication_service/src/api/middleware/has_payment_source.rs b/services/authentication_service/src/api/middleware/has_payment_source.rsdeleted file mode 100644index ab2289bd97..0000000000--- a/services/authentication_service/src/api/middleware/has_payment_source.rs+++ /dev/null@@ -1,131 +0,0 @@-//! This module provides the stripe_customer_id and default_pm_id in the request context.--// TODO: this should be grabbed from macrodb which is populated through webhooks to save a lot of time and potential rate limiting issues calling stripe.-use std::sync::Arc;--use axum::{- Extension, Json, RequestPartsExt,- extract::{FromRef, FromRequestParts},- http::{StatusCode, request::Parts},- response::{IntoResponse, Response},-};-use macro_user_id::user_id::MacroUserId;-use model::{response::ErrorResponse, user::UserContext};-use sqlx::PgPool;-use thiserror::Error;--#[derive(Debug)]-pub struct StripeCustomerExtractor {- /// The users stripe customer id- #[allow(dead_code)]- pub stripe_customer_id: stripe::CustomerId,- /// The payment source id for the customer- #[allow(dead_code)]- pub default_pm_id: stripe::PaymentMethodId,-}--/// Possible errors when getting stripe customer information for the user-#[derive(Debug, Error)]-pub enum StripeCustomerError {- /// The user does not have a stripe customer id- #[error("No stripe customer id")]- NoStripeCustomerId,- #[error("Invalid stripe customer id")]- InvalidStripeCustomerId,- /// The user does not have a default payment- #[error("No default payment")]- NoDefaultPayment,- /// Failed to get the user's context- #[error("Failed to get user context")]- UserContextErr,- /// Failed to get the data from the storage layer.- /// This could be the stripe client or macrodb.- #[error("Failed to get stripe subscription")]- StorageLayerError(#[from] anyhow::Error),-}--impl IntoResponse for StripeCustomerError {- fn into_response(self) -> Response {- let err = Json(ErrorResponse {- message: self.to_string().into(),- });- match self {- StripeCustomerError::NoStripeCustomerId => (StatusCode::UNAUTHORIZED, err),- StripeCustomerError::NoDefaultPayment => (StatusCode::UNAUTHORIZED, err),- StripeCustomerError::InvalidStripeCustomerId => {- (StatusCode::INTERNAL_SERVER_ERROR, err)- }- StripeCustomerError::UserContextErr => (StatusCode::INTERNAL_SERVER_ERROR, err),- StripeCustomerError::StorageLayerError(_error) => {- (StatusCode::INTERNAL_SERVER_ERROR, err)- }- }- .into_response()- }-}--impl<S> FromRequestParts<S> for StripeCustomerExtractor-where- PgPool: FromRef<S>,- Arc<stripe::Client>: FromRef<S>,- S: Send + Sync + Clone + 'static,-{- type Rejection = StripeCustomerError;-- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let db = PgPool::from_ref(state);- let stripe_client: Arc<stripe::Client> = Arc::from_ref(state);-- let Extension(UserContext { user_id, .. }) = parts- .extract()- .await- .map_err(|_| StripeCustomerError::UserContextErr)?;-- let user_id = MacroUserId::parse_from_str(&user_id)- .map_err(|_| StripeCustomerError::UserContextErr)?- .lowercase();-- let stripe_customer_id =- macro_db_client::user::get::get_stripe_customer_id_by_user_id(&db, &user_id)- .await- .map_err(|e| match e {- sqlx::Error::RowNotFound => StripeCustomerError::UserContextErr,- _ => StripeCustomerError::StorageLayerError(anyhow::anyhow!(- "unable to get stripe customer id"- )),- })?;-- let stripe_customer_id =- stripe_customer_id.ok_or(StripeCustomerError::NoStripeCustomerId)?;-- let stripe_customer_id: stripe::CustomerId = stripe_customer_id- .parse()- .map_err(|_| StripeCustomerError::InvalidStripeCustomerId)?;-- let customer = stripe::Customer::retrieve(- &stripe_client,- &stripe_customer_id,- &["invoice_settings.default_payment_method"],- )- .await- .map_err(|_| {- StripeCustomerError::StorageLayerError(anyhow::anyhow!(- "unable to get stripe customer payment methods"- ))- })?;-- let default_pm_id = customer- .invoice_settings- .and_then(|settings| settings.default_payment_method)- .map(|pm| match pm {- stripe::Expandable::Id(id) => id,- stripe::Expandable::Object(pm) => pm.id,- })- .ok_or(StripeCustomerError::NoDefaultPayment)?;-- Ok(Self {- stripe_customer_id,- default_pm_id,- })- }-}diff --git a/services/authentication_service/src/api/middleware/team_access.rs b/services/authentication_service/src/api/middleware/team_access.rsdeleted file mode 100644index 77b983dac2..0000000000--- a/services/authentication_service/src/api/middleware/team_access.rs+++ /dev/null@@ -1,115 +0,0 @@-use crate::api::team::TeamPathParam;-use axum::{- Extension, Json, RequestPartsExt,- extract::{FromRef, FromRequestParts, Path},- http::{StatusCode, request::Parts},- response::{IntoResponse, Response},-};-use model::{response::ErrorResponse, user::UserContext};-use models_team::TeamRole;-use sqlx::PgPool;-use std::marker::PhantomData;-use thiserror::Error;--trait BuildTeamAccess {- fn into_team_role() -> TeamRole;-}--#[derive(Debug)]-pub struct MemberRole;-#[derive(Debug)]-pub struct AdminRole;-#[derive(Debug)]-pub struct OwnerRole;--impl BuildTeamAccess for MemberRole {- fn into_team_role() -> TeamRole {- TeamRole::Member- }-}--impl BuildTeamAccess for AdminRole {- fn into_team_role() -> TeamRole {- TeamRole::Admin- }-}--impl BuildTeamAccess for OwnerRole {- fn into_team_role() -> TeamRole {- TeamRole::Owner- }-}--#[derive(Debug)]-pub struct TeamAccessRoleExtractor<T> {- #[allow(dead_code)]- pub role: TeamRole,- desired: PhantomData<T>,-}--#[derive(Debug, Error)]-pub enum RoleAccessErr {- #[error("Team id not found in path params")]- MissingTeamId,- /// user context failed to extract- #[error("Internal server err")]- UserContextErr,- #[error("Failed to get team role")]- DbErr(#[from] anyhow::Error),- #[error("User is not a member of this team")]- NotInTeam,- #[error("User does not have access to the desired resource")]- NotHighEnoughAccess,-}--impl IntoResponse for RoleAccessErr {- fn into_response(self) -> Response {- let err = Json(ErrorResponse {- message: self.to_string().into(),- });- match self {- RoleAccessErr::MissingTeamId => (StatusCode::BAD_REQUEST, err),- RoleAccessErr::UserContextErr => (StatusCode::INTERNAL_SERVER_ERROR, err),- RoleAccessErr::DbErr(_error) => (StatusCode::INTERNAL_SERVER_ERROR, err),- RoleAccessErr::NotInTeam => (StatusCode::UNAUTHORIZED, err),- RoleAccessErr::NotHighEnoughAccess => (StatusCode::UNAUTHORIZED, err),- }- .into_response()- }-}--impl<S, T> FromRequestParts<S> for TeamAccessRoleExtractor<T>-where- PgPool: FromRef<S>,- S: Send + Sync + Clone + 'static,- T: BuildTeamAccess,-{- type Rejection = RoleAccessErr;-- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let db = PgPool::from_ref(state);-- let Extension(UserContext { user_id, .. }) = parts- .extract()- .await- .map_err(|_| RoleAccessErr::UserContextErr)?;-- let Path(TeamPathParam { team_id }) = parts- .extract()- .await- .map_err(|_| RoleAccessErr::MissingTeamId)?;-- let team_role = macro_db_client::team::get::get_team_role(&db, &team_id, &user_id).await?;-- let team_role = team_role.ok_or(RoleAccessErr::NotInTeam)?;-- if team_role < T::into_team_role() {- return Err(RoleAccessErr::NotHighEnoughAccess);- }-- Ok(Self {- role: team_role,- desired: PhantomData,- })- }-}diff --git a/services/authentication_service/src/api/mod.rs b/services/authentication_service/src/api/mod.rsindex 8b299c64f1..9fc2cda505 100644--- a/services/authentication_service/src/api/mod.rs+++ b/services/authentication_service/src/api/mod.rs@@ -7,7 +7,6 @@ use macro_tower_layers::MacroRequestIdAndTracingLayer;use native_app_service::inbound::RouterState;use std::net::SocketAddr;use std::time::Duration;-use tower::ServiceBuilder;use tower_http::compression::CompressionLayer;use utoipa::OpenApi;use utoipa_swagger_ui::SwaggerUi;@@ -27,11 +26,13 @@ mod github_pull_requests;mod health;mod internal;mod jwt;+mod jwt_session;mod login;mod logout;mod oauth;mod oauth2;mod permissions;+mod permissions_extractor;mod session;mod user;mod webhooks;@@ -81,43 +82,22 @@ fn api_router(state: ApiContext) -> Router<ApiContext> {},)).nest("/internal", internal::router())- .nest("/permissions", permissions::router(state.jwt_args.clone()))+ .nest("/permissions", permissions::router()).nest("/login", login::router(state.clone()))- .nest("/logout", logout::router(state.jwt_args.clone()))+ .nest("/logout", logout::router()).nest("/oauth", oauth::router(state.clone())).nest("/oauth2", oauth2::router())- .nest("/user", user::router(state.clone(), state.jwt_args.clone()))- .nest(- "/link",- link::router(state.clone()).layer(ServiceBuilder::new().layer(- axum::middleware::from_fn_with_state(- state.jwt_args.clone(),- macro_middleware::auth::decode_jwt::handler,- ),- )),- )- .nest(- "/github_pull_requests",- github_pull_requests::router().layer(ServiceBuilder::new().layer(- axum::middleware::from_fn_with_state(- state.jwt_args.clone(),- macro_middleware::auth::decode_jwt::handler,- ),- )),- )+ .nest("/user", user::router())+ .nest("/link", link::router())+ .nest("/github_pull_requests", github_pull_requests::router()).nest("/team",teams::inbound::axum_router::teams_router(teams::inbound::axum_router::TeamRouterState {service: state.teams_service.clone(),entity_access_service: state.entity_access_service.clone(),+ authorization_state: state.authorization_state.clone(),},- )- .layer(- ServiceBuilder::new().layer(axum::middleware::from_fn_with_state(- state.jwt_args.clone(),- macro_middleware::auth::decode_jwt::handler,- )),),).nest(@@ -126,22 +106,17 @@ fn api_router(state: ApiContext) -> Router<ApiContext> {referral::inbound::axum_router::ReferralRouterState {service: state.referral_service.clone(),rate_limiter: state.rate_limit_service.clone(),+ authorization_state: state.authorization_state.clone(),},- )- .layer(- ServiceBuilder::new().layer(axum::middleware::from_fn_with_state(- state.jwt_args.clone(),- macro_middleware::auth::decode_jwt::handler,- )),),)- .nest("/jwt", jwt::router(state.jwt_args.clone()))+ .nest("/jwt", jwt::router()).nest("/session", session::router()).merge(mobile_welcome_email::router(state.clone())).nest("/webhooks",- webhooks::router().layer(ServiceBuilder::new().layer(axum::middleware::from_fn(+ webhooks::router().layer(axum::middleware::from_fn(macro_middleware::connection_drop_prevention_handler,- ))),+ )),)}diff --git a/services/authentication_service/src/api/permissions/get_user_permissions.rs b/services/authentication_service/src/api/permissions/get_user_permissions.rsindex b82c64830e..13bef33dc1 100644--- a/services/authentication_service/src/api/permissions/get_user_permissions.rs+++ b/services/authentication_service/src/api/permissions/get_user_permissions.rs@@ -1,13 +1,12 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;-use crate::api::context::ApiContext;--use model::user::UserContext;+use crate::api::context::{ApiContext, AuthorizationService};/// Gets a list of the users permissions#[utoipa::path(@@ -20,14 +19,14 @@ use model::user::UserContext;(status = 500, body=String),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=%user_context.user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=%authorization.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {let permissions = macro_db_client::user::get_permissions::get_user_permissions(&ctx.db,- &user_context.user_id,+ &authorization.user_context.user_id,).await.map_err(|e| {diff --git a/services/authentication_service/src/api/permissions/mod.rs b/services/authentication_service/src/api/permissions/mod.rsindex 1cd27964e7..1def3ba937 100644--- a/services/authentication_service/src/api/permissions/mod.rs+++ b/services/authentication_service/src/api/permissions/mod.rs@@ -1,20 +1,12 @@-use axum::{Router, routing::get};-use macro_auth::middleware::decode_jwt::JwtValidationArgs;-use crate::api::ApiContext;+use axum::{Router, routing::get};// needs to be public in api crate for swaggerpub(in crate::api) mod get_permissions;pub(in crate::api) mod get_user_permissions;-pub fn router(jwt_args: JwtValidationArgs) -> Router<ApiContext> {+pub fn router() -> Router<ApiContext> {Router::new().route("/", get(get_permissions::handler))- .route(- "/me",- get(get_user_permissions::handler).layer(axum::middleware::from_fn_with_state(- jwt_args,- macro_middleware::auth::decode_jwt::handler,- )),- )+ .route("/me", get(get_user_permissions::handler))}diff --git a/services/authentication_service/src/api/permissions_extractor.rs b/services/authentication_service/src/api/permissions_extractor.rsnew file mode 100644index 0000000000..7ba94e6193--- /dev/null+++ b/services/authentication_service/src/api/permissions_extractor.rs@@ -0,0 +1,60 @@+use std::collections::HashSet;++use axum::{+ Json,+ extract::{FromRef, FromRequestParts},+ http::{StatusCode, request::Parts},+ response::{IntoResponse, Response},+};+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationState};+use model::response::ErrorResponse;+use sqlx::PgPool;++use crate::api::context::AuthorizationService;++/// An authorized user and their current database-backed permissions.+pub(crate) struct DbPermissionsExtractor {+ pub(crate) authorization: MacroAuthorizationExtractor<AuthorizationService>,+ pub(crate) permissions: HashSet<String>,+}++impl<S> FromRequestParts<S> for DbPermissionsExtractor+where+ S: Send + Sync + 'static,+ PgPool: FromRef<S>,+ MacroAuthorizationState<AuthorizationService>: FromRef<S>,+{+ type Rejection = Response;++ async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {+ let authorization =+ MacroAuthorizationExtractor::<AuthorizationService>::from_request_parts(parts, state)+ .await+ .map_err(IntoResponse::into_response)?;+ let db = PgPool::from_ref(state);+ let permissions = macro_db_client::user::get_permissions::get_user_permissions(+ &db,+ &authorization.user_context.user_id,+ )+ .await+ .map_err(|error| {+ tracing::error!(+ error = ?error,+ user_id = %authorization.user_context.user_id,+ "unable to get user permissions"+ );+ (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(ErrorResponse {+ message: "internal error".into(),+ }),+ )+ .into_response()+ })?;++ Ok(Self {+ authorization,+ permissions,+ })+ }+}diff --git a/services/authentication_service/src/api/swagger.rs b/services/authentication_service/src/api/swagger.rsindex 81871adad3..e466e2ead2 100644--- a/services/authentication_service/src/api/swagger.rs+++ b/services/authentication_service/src/api/swagger.rs@@ -124,24 +124,24 @@ use model::user::{email::verify_email_link::handler,/// /team- teams::inbound::axum_router::create_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::delete_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::join_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::get_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::invite_to_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::get_team_invites::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::patch_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::patch_team_crm_settings::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::toggle_auto_join_domain::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::reject_invitation::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::get_user_invites::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::get_user_teams::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::remove_user_from_team::handler::<crate::api::context::TeamsServiceType>,- teams::inbound::axum_router::delete_team_invite::handler::<crate::api::context::TeamsServiceType>,+ teams::inbound::axum_router::create_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::delete_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::join_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::get_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::invite_to_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::get_team_invites::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::patch_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::patch_team_crm_settings::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::toggle_auto_join_domain::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::reject_invitation::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::get_user_invites::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::get_user_teams::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::remove_user_from_team::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,+ teams::inbound::axum_router::delete_team_invite::handler::<crate::api::context::TeamsServiceType, crate::api::context::EntityAccessServiceType, crate::api::context::AuthorizationService>,/// /referral- referral::inbound::axum_router::get_referral_code_handler::<crate::api::context::ReferralServiceType>,- referral::inbound::axum_router::post_referral_invite_handler::<crate::api::context::ReferralServiceType>,+ referral::inbound::axum_router::get_referral_code_handler::<crate::api::context::ReferralServiceType, crate::api::context::RateLimiter, crate::api::context::AuthorizationService>,+ referral::inbound::axum_router::post_referral_invite_handler::<crate::api::context::ReferralServiceType, crate::api::context::RateLimiter, crate::api::context::AuthorizationService>,/// /mobile-welcome-emailmobile_welcome_email::handler,diff --git a/services/authentication_service/src/api/user/delete_user.rs b/services/authentication_service/src/api/user/delete_user.rsindex 70d386943c..65e3b9222d 100644--- a/services/authentication_service/src/api/user/delete_user.rs+++ b/services/authentication_service/src/api/user/delete_user.rs@@ -1,19 +1,19 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::decode_jwt::JwtContext;+use macro_authorization::MacroAuthorizationExtractor;use tower_cookies::Cookies;use crate::api::{- context::ApiContext,+ context::{ApiContext, AuthorizationService},+ jwt_session::JwtSessionContext,utils::{create_access_token_cookie, create_refresh_token_cookie},};use model::response::{ErrorResponse, GenericSuccessResponse};-use model::user::UserContext;/// Deletes the user who calls this endpoint#[utoipa::path(@@ -26,13 +26,14 @@ use model::user::UserContext;(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, jwt_context), fields(user_id=%user_context.user_id))]+#[tracing::instrument(skip(ctx, authorization, jwt_session, cookies), fields(user_id=%authorization.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,- jwt_context: Extension<JwtContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,+ JwtSessionContext(jwt_session): JwtSessionContext,cookies: Cookies,) -> Result<Response, Response> {+ let user_context = &authorization.user_context;let user_id = &*user_context.user_id;// This may seem dumb, but if you delete this account it will delete my fusionauth account and// we will then be locked out of fusionauth. So this is a way to prevent any accidental fuck@@ -51,9 +52,11 @@ pub async fn handler(refresh_token_cookie.set_expires(Some(time::OffsetDateTime::now_utc()));cookies.add(refresh_token_cookie);- // Logout of fusionauth- if let Err(e) = ctx.auth_client.logout(&jwt_context.tid).await {- tracing::warn!(error=%e, "error logging out");+ // Logout of fusionauth when the request used a FusionAuth session.+ if let Some(jwt_context) = jwt_session+ && let Err(e) = ctx.auth_client.logout(&jwt_context.tid).await+ {+ tracing::warn!(error=?e, "error logging out");}let email = user_id.replace("macro|", "");diff --git a/services/authentication_service/src/api/user/get_legacy_user_permissions.rs b/services/authentication_service/src/api/user/get_legacy_user_permissions.rsindex d19b931a3b..262e433d0e 100644--- a/services/authentication_service/src/api/user/get_legacy_user_permissions.rs+++ b/services/authentication_service/src/api/user/get_legacy_user_permissions.rs@@ -1,17 +1,15 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::user_permissions::attach_user_permissions::PermissionsExtractor;use macro_user_id::user_id::MacroUserId;use roles_and_permissions::domain::model::PermissionId;-use crate::api::context::ApiContext;+use crate::api::{context::ApiContext, permissions_extractor::DbPermissionsExtractor};use model::response::ErrorResponse;-use model::user::UserContext;#[derive(serde::Serialize, Debug, utoipa::ToSchema)]#[serde(rename_all = "camelCase")]@@ -94,13 +92,12 @@ impl IntoResponse for GetLegacyUserPermissionsError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, permissions), err, fields(user_id=%user_context.user_id))]+#[tracing::instrument(skip(ctx, db_permissions), err, fields(user_id=%db_permissions.authorization.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,- PermissionsExtractor(permissions): PermissionsExtractor,+ db_permissions: DbPermissionsExtractor,) -> Result<GetLegacyUserPermissionsResponse, GetLegacyUserPermissionsError> {- let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ let user_id = MacroUserId::parse_from_str(&db_permissions.authorization.user_context.user_id).map_err(|_| GetLegacyUserPermissionsError::InvalidMacroUserId)?.lowercase();@@ -110,21 +107,23 @@ pub async fn handler(.await.map_err(GetLegacyUserPermissionsError::InternalError)?;- let license_status =- if permissions.contains(&PermissionId::ReadProfessionalFeatures.to_string()) {- // If the user has premium permission their license status is active- "active"- } else {- // By default, we can be lazy and just say they are inactive- // If the requirements change, we will need to update this to actually check the user's- // stripe subscription if present- "inactive"- };+ let license_status = if db_permissions+ .permissions+ .contains(&PermissionId::ReadProfessionalFeatures.to_string())+ {+ // If the user has premium permission their license status is active+ "active"+ } else {+ // By default, we can be lazy and just say they are inactive+ // If the requirements change, we will need to update this to actually check the user's+ // stripe subscription if present+ "inactive"+ };Ok(GetLegacyUserPermissionsResponse {user_id: user_id.as_ref().to_string(),email: email.as_ref().to_string(),- permissions: permissions.into_iter().collect(),+ permissions: db_permissions.permissions.into_iter().collect(),name: legacy_user_info.name,license_status: license_status.to_string(),tutorial_complete: legacy_user_info.tutorial_complete,diff --git a/services/authentication_service/src/api/user/get_name.rs b/services/authentication_service/src/api/user/get_name.rsindex 18b81e3752..ce609c828d 100644--- a/services/authentication_service/src/api/user/get_name.rs+++ b/services/authentication_service/src/api/user/get_name.rs@@ -1,15 +1,15 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};use macro_db_client::user::get_user_name::get_user_name;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use model::user::UserName;/// Retrieves the name of a particular user.@@ -23,15 +23,15 @@ use model::user::UserName;(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context))]+#[tracing::instrument(skip(ctx, authorization))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {- let user_name = get_user_name(&ctx.db, &user_context.fusion_user_id)+ let user_name = get_user_name(&ctx.db, &authorization.user_context.fusion_user_id).await.map_err(|e| {- tracing::error!(error=?e, user_context.user_id, "failed to update user name");+ tracing::error!(error=?e, authorization.user_context.user_id, "failed to update user name");(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()})?;Ok((StatusCode::OK, Json(user_name)).into_response())diff --git a/services/authentication_service/src/api/user/get_user_info.rs b/services/authentication_service/src/api/user/get_user_info.rsindex 88fd97d65f..2892c70bd4 100644--- a/services/authentication_service/src/api/user/get_user_info.rs+++ b/services/authentication_service/src/api/user/get_user_info.rs@@ -1,15 +1,15 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use model::authentication::user::GetUserInfo;use model::response::ErrorResponse;-use model::user::UserContext;/// Gets the calling user's info#[utoipa::path(@@ -22,14 +22,14 @@ use model::user::UserContext;(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=%user_context.user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=%authorization.macro_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {let permissions = macro_db_client::user::get_permissions::get_user_permissions(&ctx.db,- &user_context.user_id,+ authorization.macro_user_id.as_ref(),).await.map_err(|e| {@@ -46,8 +46,8 @@ pub async fn handler(Ok((StatusCode::OK,Json(GetUserInfo {- user_id: user_context.user_id.clone(),- organization_id: user_context.organization_id,+ user_id: authorization.macro_user_id.to_string(),+ organization_id: authorization.user_context.organization_id,permissions: permissions.into_iter().collect(),}),)diff --git a/services/authentication_service/src/api/user/get_user_link_exists.rs b/services/authentication_service/src/api/user/get_user_link_exists.rsindex ebc20217ba..3ec66941de 100644--- a/services/authentication_service/src/api/user/get_user_link_exists.rs+++ b/services/authentication_service/src/api/user/get_user_link_exists.rs@@ -1,15 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};use utoipa::ToSchema;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;#[derive(serde::Deserialize, serde::Serialize, Debug)]pub struct Params {@@ -39,10 +39,10 @@ pub struct UserLinkResponse {(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context), fields(user_id = user_context.user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id = authorization.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Query(params): extract::Query<Params>,) -> Result<Response, Response> {tracing::info!("get_user_link_exists");@@ -76,10 +76,10 @@ pub async fn handler(let links = ctx.auth_client- .get_links(&user_context.fusion_user_id, Some(idp_id.clone()))+ .get_links(&authorization.user_context.fusion_user_id, Some(idp_id.clone())).await.map_err(|e| {- tracing::error!(error=?e, "error fetching links for userid {} and idp id {}", user_context.fusion_user_id, idp_id.as_str());+ tracing::error!(error=?e, "error fetching links for userid {} and idp id {}", authorization.user_context.fusion_user_id, idp_id.as_str());(StatusCode::INTERNAL_SERVER_ERROR,Json(ErrorResponse {diff --git a/services/authentication_service/src/api/user/get_user_organization.rs b/services/authentication_service/src/api/user/get_user_organization.rsindex 75b1fa6eff..5b8e19c41c 100644--- a/services/authentication_service/src/api/user/get_user_organization.rs+++ b/services/authentication_service/src/api/user/get_user_organization.rs@@ -1,12 +1,12 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;#[derive(Debug, serde::Serialize, utoipa::ToSchema)]#[serde(rename_all = "camelCase")]@@ -68,12 +68,12 @@ impl IntoResponse for GetUserOrganizationResponse {(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=?user_context.user_id))]+#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=?user_context.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ user_context: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<GetUserOrganizationResponse, UserOrganizationError> {- let organization_id = if let Some(organization_id) = user_context.organization_id {+ let organization_id = if let Some(organization_id) = user_context.user_context.organization_id {organization_id} else {return Ok(GetUserOrganizationResponse::NoOrganization);diff --git a/services/authentication_service/src/api/user/get_user_quota.rs b/services/authentication_service/src/api/user/get_user_quota.rsindex 7656dd8414..7e150b4525 100644--- a/services/authentication_service/src/api/user/get_user_quota.rs+++ b/services/authentication_service/src/api/user/get_user_quota.rs@@ -1,5 +1,5 @@use axum::{- Extension, Json,+ Json,extract::State,http::StatusCode,response::{IntoResponse, Response},@@ -8,10 +8,9 @@ use macro_user_id::user_id::MacroUserId;use roles_and_permissions::domain::model::PermissionId;use user_quota::UserQuota;-use crate::api::context::ApiContext;+use crate::api::{context::ApiContext, permissions_extractor::DbPermissionsExtractor};use model::response::ErrorResponse;-use model::user::UserContext;/// Retrieves the users quota./// Returns NO_CONTENT if the user is a premium user with no quota.@@ -26,45 +25,40 @@ use model::user::UserContext;(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=?user_context.user_id))]+#[tracing::instrument(skip(ctx, db_permissions), fields(user_id=?db_permissions.authorization.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ db_permissions: DbPermissionsExtractor,) -> Result<Response, Response> {- if let Some(permissions) = user_context.permissions.as_ref() {- // If the user if premium, return NO_CONTENT- if permissions.contains(&PermissionId::ReadProfessionalFeatures.to_string()) {- return Ok((StatusCode::NO_CONTENT).into_response());- }+ let user_context = &db_permissions.authorization.user_context;- let user_id = MacroUserId::parse_from_str(&user_context.user_id)- .map_err(|e| {- tracing::error!(error=?e, user_id=?user_context.user_id, "unable to parse user id");- (- StatusCode::INTERNAL_SERVER_ERROR,- Json(ErrorResponse {- message: "unable to parse user id".into(),- }),- )- .into_response()- })?- .lowercase();+ // If the user is premium, return NO_CONTENT.+ if db_permissions+ .permissions+ .contains(&PermissionId::ReadProfessionalFeatures.to_string())+ {+ return Ok(StatusCode::NO_CONTENT.into_response());+ }- let quota = macro_db_client::user_quota::get_user_quota(&ctx.db, &user_id)- .await- .map_err(|e| {- tracing::error!(error=?e, user_id=?user_context.user_id, "unable to get user quota");- (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()- })?;+ let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ .map_err(|e| {+ tracing::error!(error=?e, user_id=?user_context.user_id, "unable to parse user id");+ (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(ErrorResponse {+ message: "unable to parse user id".into(),+ }),+ )+ .into_response()+ })?+ .lowercase();- Ok((StatusCode::OK, Json(quota)).into_response())- } else {- Err((- StatusCode::INTERNAL_SERVER_ERROR,- Json(ErrorResponse {- message: "no permissions were found for user".into(),- }),- )- .into_response())- }+ let quota = macro_db_client::user_quota::get_user_quota(&ctx.db, &user_id)+ .await+ .map_err(|e| {+ tracing::error!(error=?e, user_id=?user_context.user_id, "unable to get user quota");+ (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()+ })?;++ Ok((StatusCode::OK, Json(quota)).into_response())}diff --git a/services/authentication_service/src/api/user/mod.rs b/services/authentication_service/src/api/user/mod.rsindex c98209f17c..d6e521010a 100644--- a/services/authentication_service/src/api/user/mod.rs+++ b/services/authentication_service/src/api/user/mod.rs@@ -2,8 +2,6 @@ use axum::{Router,routing::{delete, get, patch, post, put},};-use macro_auth::middleware::decode_jwt::JwtValidationArgs;-use tower::ServiceBuilder;use tower_cookies::CookieManagerLayer;use crate::api::{ApiContext, context::EntityAccessServiceType};@@ -28,13 +26,13 @@ pub(in crate::api) mod put_name;pub(in crate::api) mod put_profile_picture;pub(in crate::api) mod stripe;-pub fn router(state: ApiContext, jwt_args: JwtValidationArgs) -> Router<ApiContext> {+pub fn router() -> Router<ApiContext> {Router::new().route("/", post(create_user::handler))- .merge(router_with_auth(state, jwt_args))+ .merge(router_with_auth())}-fn router_with_auth(state: ApiContext, jwt_args: JwtValidationArgs) -> Router<ApiContext> {+fn router_with_auth() -> Router<ApiContext> {Router::new().route("/me", get(get_user_info::handler)).route("/me", delete(delete_user::handler))@@ -50,13 +48,7 @@ fn router_with_auth(state: ApiContext, jwt_args: JwtValidationArgs) -> Router<Ap.route("/link_exists", get(get_user_link_exists::handler)).route("/tutorial", patch(patch_tutorial::handler)).route("/ai_consent", patch(patch_ai_consent::handler))- .route(- "/quota",- get(get_user_quota::handler).layer(axum::middleware::from_fn_with_state(- state.clone(),- macro_middleware::user_permissions::attach_user_permissions::handler,- )),- )+ .route("/quota", get(get_user_quota::handler)).route("/stripe/checkoutv2",post(@@ -76,12 +68,5 @@ fn router_with_auth(state: ApiContext, jwt_args: JwtValidationArgs) -> Router<Ap.route("/organization", get(get_user_organization::handler)).route("/group", patch(patch_user_group::handler)).route("/onboarding", patch(patch_user_onboarding::handler))- .layer(- ServiceBuilder::new()- .layer(CookieManagerLayer::new())- .layer(axum::middleware::from_fn_with_state(- jwt_args,- macro_middleware::auth::decode_jwt::handler,- )),- )+ .layer(CookieManagerLayer::new())}diff --git a/services/authentication_service/src/api/user/patch_ai_consent.rs b/services/authentication_service/src/api/user/patch_ai_consent.rsindex bf388336f7..1a1772fb04 100644--- a/services/authentication_service/src/api/user/patch_ai_consent.rs+++ b/services/authentication_service/src/api/user/patch_ai_consent.rs@@ -1,17 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_user_id::user_id::MacroUserId;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};-use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,-};+use model::response::{EmptyResponse, ErrorResponse};use utoipa::ToSchema;#[derive(Default, Debug, serde::Serialize, serde::Deserialize, ToSchema)]@@ -69,13 +67,13 @@ impl IntoResponse for PatchAiConsentError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_id))]+#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ user_context: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PatchAiConsentRequest>,) -> Result<Json<EmptyResponse>, PatchAiConsentError> {- let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ let user_id = MacroUserId::parse_from_str(&user_context.user_context.user_id).map_err(|_| PatchAiConsentError::InvalidMacroUserId)?.lowercase();diff --git a/services/authentication_service/src/api/user/patch_tutorial.rs b/services/authentication_service/src/api/user/patch_tutorial.rsindex edb25fd352..78c66a75e4 100644--- a/services/authentication_service/src/api/user/patch_tutorial.rs+++ b/services/authentication_service/src/api/user/patch_tutorial.rs@@ -1,17 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_user_id::user_id::MacroUserId;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};-use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,-};+use model::response::{EmptyResponse, ErrorResponse};use utoipa::ToSchema;#[derive(Default, Debug, serde::Serialize, serde::Deserialize, ToSchema)]@@ -69,13 +67,13 @@ impl IntoResponse for PatchTutorialCompleteError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_id))]+#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ user_context: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PatchUserTutorialRequest>,) -> Result<Json<EmptyResponse>, PatchTutorialCompleteError> {- let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ let user_id = MacroUserId::parse_from_str(&user_context.user_context.user_id).map_err(|_| PatchTutorialCompleteError::InvalidMacroUserId)?.lowercase();diff --git a/services/authentication_service/src/api/user/patch_user_group.rs b/services/authentication_service/src/api/user/patch_user_group.rsindex 5199fab9ab..ca7889307c 100644--- a/services/authentication_service/src/api/user/patch_user_group.rs+++ b/services/authentication_service/src/api/user/patch_user_group.rs@@ -1,17 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_user_id::user_id::MacroUserId;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};-use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,-};+use model::response::{EmptyResponse, ErrorResponse};use utoipa::ToSchema;#[derive(Default, Debug, serde::Serialize, serde::Deserialize, ToSchema)]@@ -68,13 +66,13 @@ impl IntoResponse for PatchUserGroupError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_id))]+#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ user_context: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PatchUserGroupRequest>,) -> Result<Json<EmptyResponse>, PatchUserGroupError> {- let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ let user_id = MacroUserId::parse_from_str(&user_context.user_context.user_id).map_err(|_| PatchUserGroupError::InvalidMacroUserId)?.lowercase();diff --git a/services/authentication_service/src/api/user/patch_user_onboarding.rs b/services/authentication_service/src/api/user/patch_user_onboarding.rsindex c800bb2b1e..36d2a10e45 100644--- a/services/authentication_service/src/api/user/patch_user_onboarding.rs+++ b/services/authentication_service/src/api/user/patch_user_onboarding.rs@@ -1,17 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::MacroAuthorizationExtractor;use macro_user_id::user_id::MacroUserId;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};-use model::{- response::{EmptyResponse, ErrorResponse},- user::UserContext,-};+use model::response::{EmptyResponse, ErrorResponse};use utoipa::ToSchema;#[derive(Default, Debug, serde::Serialize, serde::Deserialize, ToSchema)]@@ -75,13 +73,13 @@ impl IntoResponse for PatchUserOnboardingError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_id))]+#[tracing::instrument(skip(ctx, user_context), err, fields(user_id=user_context.user_context.user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ user_context: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PatchUserOnboardingRequest>,) -> Result<Json<EmptyResponse>, PatchUserOnboardingError> {- let user_id = MacroUserId::parse_from_str(&user_context.user_id)+ let user_id = MacroUserId::parse_from_str(&user_context.user_context.user_id).map_err(|_| PatchUserOnboardingError::InvalidMacroUserId)?.lowercase();diff --git a/services/authentication_service/src/api/user/post_get_names.rs b/services/authentication_service/src/api/user/post_get_names.rsindex 9f210a196d..12d1cff3f4 100644--- a/services/authentication_service/src/api/user/post_get_names.rs+++ b/services/authentication_service/src/api/user/post_get_names.rs@@ -4,10 +4,10 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};+use macro_authorization::{InternalMacroAuthorizationExtractor, MacroAuthorizationExtractor};use macro_db_client::user::get_user_name::get_user_names;-use macro_middleware::auth::internal_access::ValidInternalKey;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use model::response::ErrorResponse;use model::user::UserNames;@@ -28,22 +28,31 @@ pub struct PostGetNamesRequestBody {(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx))]+#[tracing::instrument(skip(ctx, _authorization))]pub async fn handler_external(State(ctx): State<ApiContext>,+ _authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PostGetNamesRequestBody>,+) -> Result<Response, Response> {+ lookup_names(&ctx, req).await+}++pub async fn handler_internal(+ State(ctx): State<ApiContext>,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,+ extract::Json(req): extract::Json<PostGetNamesRequestBody>,+) -> Result<Response, Response> {+ lookup_names(&ctx, req).await+}++async fn lookup_names(+ ctx: &ApiContext,+ req: PostGetNamesRequestBody,) -> Result<Response, Response> {let user_names = get_user_names(&ctx.db, &req.user_ids).await.map_err(|e| {tracing::error!(error=?e, "failed to update user name");(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()})?;- Ok((StatusCode::OK, Json(UserNames { names: user_names })).into_response())-}-pub async fn handler_internal(- ctx: State<ApiContext>,- _valid_access: ValidInternalKey,- req: extract::Json<PostGetNamesRequestBody>,-) -> Result<Response, Response> {- handler_external(ctx, req).await+ Ok((StatusCode::OK, Json(UserNames { names: user_names })).into_response())}diff --git a/services/authentication_service/src/api/user/post_get_names_with_email.rs b/services/authentication_service/src/api/user/post_get_names_with_email.rsindex 92f69f4a1e..66884a329a 100644--- a/services/authentication_service/src/api/user/post_get_names_with_email.rs+++ b/services/authentication_service/src/api/user/post_get_names_with_email.rs@@ -1,15 +1,16 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::{- Extension, Json,+ Json,extract::{self, State},http::StatusCode,};+use macro_authorization::MacroAuthorizationExtractor;use macro_db_client::user::get_user_name::get_user_names_with_email;use macro_user_id::user_id::MacroUserId;use macro_user_id::{cowlike::CowLike, lowercased::Lowercase};use model::response::ErrorResponse;-use model::user::{UserContext, UserNames};+use model::user::UserNames;use non_empty::NonEmpty;#[derive(Default, Debug, serde::Serialize, serde::Deserialize, utoipa::ToSchema)]@@ -29,10 +30,10 @@ pub struct GetNamesWithEmailRequestBody {(status = 500, body=ErrorResponse),),)]-#[tracing::instrument(skip(ctx))]+#[tracing::instrument(skip(ctx, authorization))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<GetNamesWithEmailRequestBody>,) -> Result<Json<UserNames>, (StatusCode, String)> {let user_profile_ids: NonEmpty<Vec<MacroUserId<Lowercase>>> = NonEmpty::new(@@ -52,11 +53,15 @@ pub async fn handler()})?;- let user_names = get_user_names_with_email(&ctx.db, &user_context.user_id, user_profile_ids)- .await- .map_err(|e| {- tracing::error!(error=?e, "failed to get user names with email");- (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())- })?;+ let user_names = get_user_names_with_email(+ &ctx.db,+ authorization.macro_user_id.as_ref(),+ user_profile_ids,+ )+ .await+ .map_err(|e| {+ tracing::error!(error=?e, "failed to get user names with email");+ (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())+ })?;Ok(Json(UserNames { names: user_names }))}diff --git a/services/authentication_service/src/api/user/post_profile_pictures.rs b/services/authentication_service/src/api/user/post_profile_pictures.rsindex 4c78a8b6f3..8b5bfff203 100644--- a/services/authentication_service/src/api/user/post_profile_pictures.rs+++ b/services/authentication_service/src/api/user/post_profile_pictures.rs@@ -5,8 +5,9 @@ use axum::{response::{IntoResponse, Response},};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use macro_db_client::user::update_profile_picture::get_profile_pictures;use model::response::ErrorResponse;use model::user::ProfilePictures;@@ -28,9 +29,10 @@ pub struct GetProfilePicturesRequestBody {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx))]+#[tracing::instrument(skip(ctx, _authorization))]pub async fn handler(State(ctx): State<ApiContext>,+ _authorization: MacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<GetProfilePicturesRequestBody>,) -> Result<Response, Response> {let user_id_list = req.user_id_list;diff --git a/services/authentication_service/src/api/user/put_name.rs b/services/authentication_service/src/api/user/put_name.rsindex 65f058b01c..03c73895be 100644--- a/services/authentication_service/src/api/user/put_name.rs+++ b/services/authentication_service/src/api/user/put_name.rs@@ -1,16 +1,17 @@use axum::{- Extension, Json,+ Json,extract::{Query, State},http::StatusCode,response::{IntoResponse, Response},};use macro_db_client::user::update_user_name::update_user_name;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use model::response::EmptyResponse;use model::response::ErrorResponse;-use model::user::{PutUserNameQueryParams, UserContext};+use model::user::PutUserNameQueryParams;/// Sets the name of a particular user#[utoipa::path(@@ -24,17 +25,17 @@ use model::user::{PutUserNameQueryParams, UserContext};),params(PutUserNameQueryParams),)]-#[tracing::instrument(skip(ctx, user_context), fields(user_id = user_context.user_id, macro_user_id = user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id = authorization.user_context.user_id, macro_user_id = authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,Query(params): Query<PutUserNameQueryParams>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {tracing::info!("put_user_name");update_user_name(&ctx.db,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,params.first_name,params.last_name,)diff --git a/services/authentication_service/src/api/user/put_profile_picture.rs b/services/authentication_service/src/api/user/put_profile_picture.rsindex 3215fbdf89..8159ee42ad 100644--- a/services/authentication_service/src/api/user/put_profile_picture.rs+++ b/services/authentication_service/src/api/user/put_profile_picture.rs@@ -1,15 +1,15 @@use axum::{- Extension, Json,+ Json,extract::{Query, State},http::StatusCode,response::{IntoResponse, Response},};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use macro_authorization::MacroAuthorizationExtractor;use macro_db_client::user::update_profile_picture::update_profile_picture;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use serde::Deserialize;#[derive(Deserialize, Debug, utoipa::IntoParams)]@@ -30,21 +30,21 @@ pub struct ProfilePictureQueryParams {),params(ProfilePictureQueryParams),)]-#[tracing::instrument(skip(ctx, user_context))]+#[tracing::instrument(skip(ctx, authorization))]pub async fn handler(State(ctx): State<ApiContext>,Query(params): Query<ProfilePictureQueryParams>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {update_profile_picture(&ctx.db,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,¶ms.url,"000",).await.map_err(|e| {- tracing::error!(error=?e, user_context.user_id, "failed to update user profile picture");+ tracing::error!(error=?e, authorization.user_context.user_id, "failed to update user profile picture");(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response()})?;Ok((StatusCode::OK, Json(EmptyResponse {})).into_response())diff --git a/services/authentication_service/src/api/user/stripe/create_checkout_session_v2.rs b/services/authentication_service/src/api/user/stripe/create_checkout_session_v2.rsindex a1737d4dab..12af1af656 100644--- a/services/authentication_service/src/api/user/stripe/create_checkout_session_v2.rs+++ b/services/authentication_service/src/api/user/stripe/create_checkout_session_v2.rs@@ -1,13 +1,13 @@use axum::{Json, extract::State};use entity_access::domain::models::OwnerTeamRole;use entity_access::domain::ports::EntityAccessService;-use entity_access::inbound::axum_extractors::OptionalMacroUserTeamExtractor;-use model_user::axum_extractor::MacroUserExtractor;+use entity_access::inbound::axum_extractors::OptionalMacroUserTeamExtractorV2;+use macro_authorization::MacroAuthorizationExtractor;use serde::Deserialize;use utoipa::ToSchema;use super::{StripeOperationError, StripeSessionResponse};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use model::response::ErrorResponse;/// Tracking metadata for conversion attribution@@ -54,8 +54,8 @@ pub struct CreateCheckoutSessionV2Request {#[tracing::instrument(skip(ctx, user, optional_team), err, fields(user_id = %user.macro_user_id))]pub async fn create_checkout_session<Eas: EntityAccessService>(State(ctx): State<ApiContext>,- user: MacroUserExtractor,- optional_team: OptionalMacroUserTeamExtractor<OwnerTeamRole, Eas>,+ user: MacroAuthorizationExtractor<AuthorizationService>,+ optional_team: OptionalMacroUserTeamExtractorV2<OwnerTeamRole, Eas, AuthorizationService>,Json(req): Json<CreateCheckoutSessionV2Request>,) -> Result<Json<StripeSessionResponse>, StripeOperationError> {// Get the stripe customer ID from the databasediff --git a/services/authentication_service/src/api/user/stripe/create_portal_session.rs b/services/authentication_service/src/api/user/stripe/create_portal_session.rsindex cc90f2b902..ce18aeed82 100644--- a/services/authentication_service/src/api/user/stripe/create_portal_session.rs+++ b/services/authentication_service/src/api/user/stripe/create_portal_session.rs@@ -1,11 +1,11 @@-use axum::{Extension, Json, extract::State};+use axum::{Json, extract::State};+use macro_authorization::MacroAuthorizationExtractor;use serde::Deserialize;use utoipa::ToSchema;use super::{StripeOperationError, StripeSessionResponse};-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use model::response::ErrorResponse;-use model::user::UserContext;/// Request body for creating a Stripe portal session#[derive(Debug, Deserialize, ToSchema)]@@ -27,20 +27,19 @@ pub struct CreatePortalSessionRequest {(status = 500, body = ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err, fields(user_id = %user_context.user_id))]+#[tracing::instrument(skip(ctx, authorization), err, fields(user_id = %authorization.macro_user_id))]pub async fn create_portal_session(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Json(req): Json<CreatePortalSessionRequest>,) -> Result<Json<StripeSessionResponse>, StripeOperationError> {- let user_id =- macro_user_id::user_id::MacroUserId::parse_from_str(&user_context.user_id)?.lowercase();-// Get the stripe customer ID from the database- let stripe_customer_id =- macro_db_client::user::get::get_stripe_customer_id_by_user_id(&ctx.db, &user_id)- .await?- .ok_or(StripeOperationError::MissingStripeId)?;+ let stripe_customer_id = macro_db_client::user::get::get_stripe_customer_id_by_user_id(+ &ctx.db,+ &authorization.macro_user_id,+ )+ .await?+ .ok_or(StripeOperationError::MissingStripeId)?;let customer_id: stripe::CustomerId = stripe_customer_id.parse()?;diff --git a/services/authentication_service/src/api/webhooks/user/create_user_webhook.rs b/services/authentication_service/src/api/webhooks/user/create_user_webhook.rsindex 0fe2f613b5..b69e65ac68 100644--- a/services/authentication_service/src/api/webhooks/user/create_user_webhook.rs+++ b/services/authentication_service/src/api/webhooks/user/create_user_webhook.rs@@ -5,10 +5,13 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use rand::Rng;-use crate::{api::context::ApiContext, rate_limit_config::RATE_LIMIT_CONFIG};+use crate::{+ api::context::{ApiContext, AuthorizationService},+ rate_limit_config::RATE_LIMIT_CONFIG,+};use authentication_service::service::user::create_user::create_user;use fusionauth::error::FusionAuthClientError;use macro_user_id::{email::Email, user_id::MacroUserIdStr};@@ -16,10 +19,10 @@ use model::authentication::webhooks::FusionAuthUserWebhook;use teams::domain::team_repo::TeamService;/// FusionAuth create user webhook-#[tracing::instrument(skip(ctx, req, _internal_access), fields(email=%req.event.user.email, fusionauth_user_id=%req.event.user.id, username=?req.event.user.username, event_type=%req.event.event_type, ip_address=%req.event.info.ip_address))]+#[tracing::instrument(skip(ctx, req, _internal_authorization), fields(email=%req.event.user.email, fusionauth_user_id=%req.event.user.id, username=?req.event.user.username, event_type=%req.event.event_type, ip_address=%req.event.info.ip_address))]pub async fn handler(State(ctx): State<ApiContext>,- _internal_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<FusionAuthUserWebhook>,) -> Result<Response, Response> {tracing::info!("create_user_webhook");diff --git a/services/authentication_service/src/api/webhooks/user/delete_user_webhook.rs b/services/authentication_service/src/api/webhooks/user/delete_user_webhook.rsindex 236f14a209..ad6db2a165 100644--- a/services/authentication_service/src/api/webhooks/user/delete_user_webhook.rs+++ b/services/authentication_service/src/api/webhooks/user/delete_user_webhook.rs@@ -7,7 +7,7 @@ use comms_db_client::{channels::get_channels::get_org_channels,participants::remove_participant::{RemoveParticipantOptions, remove_participant},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use macro_user_id::user_id::MacroUserIdStr;use model::{authentication::webhooks::FusionAuthUserWebhook, user::UserInfoWithMacroUserId};use notification::domain::ports::NotificationRepository;@@ -16,14 +16,14 @@ use sqlx::{Pool, Postgres};use stripe::CustomerId;use tracing::Instrument;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use sqs_client::email::LinkManagerMessage;/// Delete user webhook-#[tracing::instrument(skip(ctx, req, _internal_access), fields(event_id=req.event.id, email=req.event.user.email,fusionauth_user_id=req.event.user.id))]+#[tracing::instrument(skip(ctx, req, _internal_authorization), fields(event_id=req.event.id, email=req.event.user.email,fusionauth_user_id=req.event.user.id))]pub async fn handler(State(ctx): State<ApiContext>,- _internal_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<FusionAuthUserWebhook>,) -> Result<Response, Response> {tracing::info!("delete user webhook");diff --git a/services/authentication_service/src/api/webhooks/user/populate_jwt.rs b/services/authentication_service/src/api/webhooks/user/populate_jwt.rsindex 27301a0146..f896330952 100644--- a/services/authentication_service/src/api/webhooks/user/populate_jwt.rs+++ b/services/authentication_service/src/api/webhooks/user/populate_jwt.rs@@ -1,21 +1,21 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::{Json,extract::{self, State},http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;use model::{authentication::webhooks::populate_jwt::{PopulateJwtWebhook, PopulateJwtWebhookResponse},user::UserInfoWithMacroUserId,};/// Populate user jwt webhook-#[tracing::instrument(skip(ctx, req, _internal_access))]+#[tracing::instrument(skip(ctx, req, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _internal_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<PopulateJwtWebhook>,) -> Result<Response, Response> {let email = req.email.to_lowercase();diff --git a/services/authentication_service/src/api/webhooks/user/update_name.rs b/services/authentication_service/src/api/webhooks/user/update_name.rsindex 1663144b18..0c01674494 100644--- a/services/authentication_service/src/api/webhooks/user/update_name.rs+++ b/services/authentication_service/src/api/webhooks/user/update_name.rs@@ -4,9 +4,9 @@ use axum::{http::StatusCode,response::{IntoResponse, Response},};-use macro_middleware::auth::internal_access::ValidInternalKey;+use macro_authorization::InternalMacroAuthorizationExtractor;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use macro_db_client::user::update_user_name::update_user_name;@@ -33,10 +33,10 @@ async fn process(}/// Update user's name-#[tracing::instrument(skip(ctx, req, _internal_access))]+#[tracing::instrument(skip(ctx, req, _internal_authorization))]pub async fn handler(State(ctx): State<ApiContext>,- _internal_access: ValidInternalKey,+ _internal_authorization: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Json(req): extract::Json<UpdateNameWebhook>,) -> Result<Response, Response> {let user_id = "macro|".to_string() + &req.email;diff --git a/services/authentication_service/src/main.rs b/services/authentication_service/src/main.rsindex 6c907a211c..145aada54e 100644--- a/services/authentication_service/src/main.rs+++ b/services/authentication_service/src/main.rs@@ -19,6 +19,7 @@ use github::{};use loops_client::LoopsClient;use macro_auth::middleware::decode_jwt::JwtValidationArgs;+use macro_authorization::{InternalAuthConfig, MacroAuthJwtValidator, MacroAuthorizationState};use macro_entrypoint::MacroEntrypoint;use macro_service_urls::AppServiceUrl;use macro_service_urls::DocumentStorageServiceUrl;@@ -51,8 +52,8 @@ use referral::{};use crate::api::context::{- ApiContext, MacroApiTokenContext, MacroApiTokenExpirySeconds, MacroApiTokenIssuer,- MacroApiTokenPrivateSecretKey, StripeWebhookSecretKey,+ ApiContext, AuthorizationService, MacroApiTokenContext, MacroApiTokenExpirySeconds,+ MacroApiTokenIssuer, MacroApiTokenPrivateSecretKey, StripeWebhookSecretKey,};use std::sync::Arc;@@ -182,6 +183,13 @@ async fn main() -> anyhow::Result<()> {let jwt_args =JwtValidationArgs::new_with_secret_manager(config.environment, &secretsmanager_client).await?;+ let authorization_state = MacroAuthorizationState::new(Arc::new(AuthorizationService::new(+ MacroAuthJwtValidator::new(jwt_args.clone()),+ InternalAuthConfig {+ api_key: internal_api_key.to_string(),+ default_user_id: None,+ },+ )));let redis_client = redis::Client::open(config.redis_uri.to_string().as_str()).context("failed to create redis client")?;@@ -339,6 +347,7 @@ async fn main() -> anyhow::Result<()> {environment: config.environment,rate_limit_service: rate_limit,jwt_args,+ authorization_state,token_context: MacroApiTokenContext {issuer: MacroApiTokenIssuer::new()?,macro_api_token_private_key,diff --git a/services/document_storage_service/src/api/context.rs b/services/document_storage_service/src/api/context.rsindex 541123336a..0796e9e920 100644--- a/services/document_storage_service/src/api/context.rs+++ b/services/document_storage_service/src/api/context.rs@@ -389,7 +389,8 @@ pub(crate) type DssWebhookRateLimiter =rate_limit::RateLimitServiceImpl<rate_limit::RedisRateLimitAdapter<redis::Client>>;/// Type alias for the product webhook router state.-pub(crate) type DssWebhookState = MacroWebhookRouterState<DssWebhookService, DssWebhookRateLimiter>;+pub(crate) type DssWebhookState =+ MacroWebhookRouterState<DssWebhookService, DssWebhookRateLimiter, AuthorizationService>;#[derive(Clone, FromRef)]pub(crate) struct ApiContext {diff --git a/services/document_storage_service/src/main.rs b/services/document_storage_service/src/main.rsindex fe7fe69acc..8a69be4e97 100644--- a/services/document_storage_service/src/main.rs+++ b/services/document_storage_service/src/main.rs@@ -680,6 +680,7 @@ async fn main() -> anyhow::Result<()> {let webhook_state = webhook::inbound::axum_router::WebhookRouterState::new(webhook_service,webhook_rate_limiter,+ authorization_state.clone(),);let webhook_ingestion_service =diff --git a/services/sync-service/src/durable_object.rs b/services/sync-service/src/durable_object.rsindex 5593f3c9d2..05b6f7d947 100644--- a/services/sync-service/src/durable_object.rs+++ b/services/sync-service/src/durable_object.rs@@ -378,7 +378,7 @@ impl DocumentSyncSession {.url()?.query_pairs().find(|(k, _)| k == "include_ai")- .map_or(true, |(_, v)| !matches!(v.as_ref(), "false" | "0"));+ .is_none_or(|(_, v)| !matches!(v.as_ref(), "false" | "0"));return self.active_peer_ids_handler(include_ai).await;}path::INITIALIZE => {@@ -1043,16 +1043,15 @@ impl DurableObject for DocumentSyncSession {.context("failed to broadcast awareness")?;}- if self.state.get_websockets().len() == 1 {- if let Ok(document_id) = self.document_id().await- && let Ok(state) = self.document_state().await- && let Ok(snapshot) = state.export_shallow_snapshot()- {- let env = self.env.clone();- self.state.wait_until(async move {- report_new_doc_state(&document_id, &snapshot, &env).await;- });- }+ if self.state.get_websockets().len() == 1+ && let Ok(document_id) = self.document_id().await+ && let Ok(state) = self.document_state().await+ && let Ok(snapshot) = state.export_shallow_snapshot()+ {+ let env = self.env.clone();+ self.state.wait_until(async move {+ report_new_doc_state(&document_id, &snapshot, &env).await;+ });}Ok(())}diff --git a/services/sync-service/src/websocket.rs b/services/sync-service/src/websocket.rsindex 7b584eae54..45ddf378cb 100644--- a/services/sync-service/src/websocket.rs+++ b/services/sync-service/src/websocket.rs@@ -123,20 +123,20 @@ pub async fn process_message(let touched_nodes = session_storage.append_pending_operation(update, document_state).await?;- if !touched_nodes.is_empty() {- if let Some(peer_id) = peer_id {- dss.push_blame_events(- touched_nodes- .into_iter()- .map(|node_id| crate::d1::BlameEvent {- document_id: document_id.to_string(),- node_id,- peer_id,- timestamp_ms: now_ms,- })- .collect(),- );- }+ if !touched_nodes.is_empty()+ && let Some(peer_id) = peer_id+ {+ dss.push_blame_events(+ touched_nodes+ .into_iter()+ .map(|node_id| crate::d1::BlameEvent {+ document_id: document_id.to_string(),+ node_id,+ peer_id,+ timestamp_ms: now_ms,+ })+ .collect(),+ );}}