Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(auth_service): macro authorization (#4967)

Will Hutchinson06474018e19b
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 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.lock
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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>
where
T: 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.rs
index 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.rs
index 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.rs
index 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 /send
let 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.toml
index 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.rs
index 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 = state
diff --git a/crates/teams/src/inbound/axum_router/delete_team.rs b/crates/teams/src/inbound/axum_router/delete_team.rs
index 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
.service
diff --git a/crates/teams/src/inbound/axum_router/delete_team_invite.rs b/crates/teams/src/inbound/axum_router/delete_team_invite.rs
index 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> {
state
diff --git a/crates/teams/src/inbound/axum_router/get_team.rs b/crates/teams/src/inbound/axum_router/get_team.rs
index 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.rs
index 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
.service
diff --git a/crates/teams/src/inbound/axum_router/get_user_invites.rs b/crates/teams/src/inbound/axum_router/get_user_invites.rs
index 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.rs
index 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.rs
index 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<'_>>, _>> = req
diff --git a/crates/teams/src/inbound/axum_router/join_team.rs b/crates/teams/src/inbound/axum_router/join_team.rs
index 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.rs
index 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>
where
T: 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.rs
index 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> {
state
diff --git a/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rs b/crates/teams/src/inbound/axum_router/patch_team_crm_settings.rs
index 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 = state
diff --git a/crates/teams/src/inbound/axum_router/premium_user.rs b/crates/teams/src/inbound/axum_router/premium_user.rs
index 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>
where
T: 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 @@ where
Ok(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.rs
index 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.rs
index 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> {
state
diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rs
index 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.rs
index 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
.service
diff --git a/crates/webhook/Cargo.toml b/crates/webhook/Cargo.toml
index 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, features
futures = { 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.rs
index 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 @@ where
fn 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 @@ where
parts: &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>
where
S: 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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 linking
req.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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, &params, "google_gmail").await
diff --git a/services/authentication_service/src/api/internal/post_get_existing_users.rs b/services/authentication_service/src/api/internal/post_get_existing_users.rs
index 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.rs
index 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.rs
index 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.rs
index 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 default
let 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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 link
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?;
@@ -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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 email
req.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.rs
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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 swagger
pub(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.rs
new file mode 100644
index 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.rs
index 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-email
mobile_welcome_email::handler,
diff --git a/services/authentication_service/src/api/user/delete_user.rs b/services/authentication_service/src/api/user/delete_user.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,
&params.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.rs
index 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 database
diff --git a/services/authentication_service/src/api/user/stripe/create_portal_session.rs b/services/authentication_service/src/api/user/stripe/create_portal_session.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(),
+ );
}
}