Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(email): macro authorization (#4983)
Will Hutchinson7f040bece53d
diff --git a/Cargo.lock b/Cargo.lockindex b6ce7c788a..cfea9335dd 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4729,7 +4729,6 @@ dependencies = ["macro_uuid","model-entity","model-error-response",- "model_user","models_pagination","non_empty","recursion",@@ -4896,6 +4895,7 @@ dependencies = ["last_online_tracker","lol_html","macro_auth",+ "macro_authorization","macro_aws_config","macro_config","macro_cors",diff --git a/crates/email/Cargo.toml b/crates/email/Cargo.tomlindex b8c8773bc6..0919f65269 100644--- a/crates/email/Cargo.toml+++ b/crates/email/Cargo.toml@@ -30,9 +30,7 @@ axum = ["dep:axum-extra","dep:macro_authorization","dep:model-error-response",- "dep:model_user","dep:utoipa",- "model_user/axum","models_pagination/axum",]gmail_token = ["dep:authentication_service_client", "dep:redis", "ports"]@@ -73,7 +71,6 @@ macro_uuid = { path = "../macro_uuid" }model-entity = { path = "../model-entity" }non_empty = { path = "../non_empty", optional = true }model-error-response = { path = "../model-error-response", optional = true }-model_user = { path = "../model_user", optional = true }models_pagination = { path = "../models_pagination" }recursion = { workspace = true }reqwest = { workspace = true, optional = true }diff --git a/crates/email/src/inbound/axum.rs b/crates/email/src/inbound/axum.rsindex 790b5fae35..b662fce1be 100644--- a/crates/email/src/inbound/axum.rs+++ b/crates/email/src/inbound/axum.rs@@ -19,6 +19,5 @@ pub use api_types::{};pub use axum_impls::{EmailLinkErr, EmailLinkExtractor, GetPreviewsCursorError, GetPreviewsCursorParams,- GmailAccessTokenErr, GmailAccessTokenExtractor, GmailTokenState, MultiEmailLinkExtractor,- OptionalEmailLinkExtractor,+ GmailTokenState, MultiEmailLinkExtractor,};diff --git a/crates/email/src/inbound/axum/axum_impls.rs b/crates/email/src/inbound/axum/axum_impls.rsindex 313c96388f..8160344a50 100644--- a/crates/email/src/inbound/axum/axum_impls.rs+++ b/crates/email/src/inbound/axum/axum_impls.rs@@ -1,7 +1,7 @@use crate::{domain::{models::{EmailErr, Link, PreviewView},- ports::{EmailService, GmailTokenProvider},+ ports::EmailService,},inbound::axum::{api_types::ApiSortMethod, previews_router::EmailRouterState},};@@ -17,7 +17,6 @@ use macro_authorization::{MacroAuthorizationState,};use macro_user_id::user_id::MacroUserIdStr;-use model_user::axum_extractor::{MacroUserExtractor, UserExtractorErr};use std::sync::Arc;use std::{marker::PhantomData, str::FromStr};use thiserror::Error;@@ -81,9 +80,9 @@ pub struct GetPreviewsCursorParams {pub sort_method: Option<ApiSortMethod>,}-pub struct EmailLinkExtractor<U>(pub Link, pub PhantomData<U>);+pub struct EmailLinkExtractor<U, Auth>(pub Link, pub PhantomData<(U, Auth)>);-impl<U> Clone for EmailLinkExtractor<U> {+impl<U, Auth> Clone for EmailLinkExtractor<U, Auth> {fn clone(&self) -> Self {Self(self.0.clone(), PhantomData)}@@ -101,15 +100,12 @@ pub enum EmailLinkErr {NoInboxSelected,#[error(transparent)]Authorization(#[from] MacroAuthorizationRejection),- #[error(transparent)]- UserErr(#[from] UserExtractorErr),}impl IntoResponse for EmailLinkErr {fn into_response(self) -> Response {let (status, error) = match self {EmailLinkErr::Authorization(error) => return error.into_response(),- EmailLinkErr::UserErr(error) => return error.into_response(),error @ EmailLinkErr::DbErr(_) => (StatusCode::INTERNAL_SERVER_ERROR, error),error @ EmailLinkErr::NotFound => (StatusCode::NOT_FOUND, error),error @ (EmailLinkErr::InvalidLinkIdHeader | EmailLinkErr::NoInboxSelected) => {@@ -159,18 +155,22 @@ fn parse_link_id_header(parts: &Parts) -> Result<Option<Uuid>, EmailLinkErr> {.map_err(|_| EmailLinkErr::InvalidLinkIdHeader)}-impl<S, U> FromRequestParts<S> for EmailLinkExtractor<U>+impl<S, U, Auth> FromRequestParts<S> for EmailLinkExtractor<U, Auth>whereEmailRouterState<U>: FromRef<S>,+ MacroAuthorizationState<Auth>: FromRef<S>,U: EmailService,+ Auth: MacroAuthorizationService,S: Send + Sync + 'static,{type Rejection = EmailLinkErr;async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {let header_link_id = parse_link_id_header(parts)?;- let Cached(MacroUserExtractor { macro_user_id, .. }) =- parts.extract_with_state(state).await?;+ let Cached(MacroAuthorizationExtractor { macro_user_id, .. }) = parts+ .extract_with_state(state)+ .await+ .map_err(EmailLinkErr::Authorization)?;let caller = macro_user_id.clone();let links = <EmailRouterState<U>>::from_ref(state).inner@@ -186,58 +186,29 @@ where/// endpoints fan out over all returned links. A caller with no inboxes yields an/// empty `Vec` (and hence empty results) rather than a 404 — the union over zero/// inboxes is empty, not missing.-pub struct MultiEmailLinkExtractor<U>(pub Vec<Link>, pub PhantomData<U>);+pub struct MultiEmailLinkExtractor<U, Auth>(pub Vec<Link>, pub PhantomData<(U, Auth)>);-impl<U> Clone for MultiEmailLinkExtractor<U> {+impl<U, Auth> Clone for MultiEmailLinkExtractor<U, Auth> {fn clone(&self) -> Self {Self(self.0.clone(), PhantomData)}}-impl<S, U> FromRequestParts<S> for MultiEmailLinkExtractor<U>+impl<S, U, Auth> FromRequestParts<S> for MultiEmailLinkExtractor<U, Auth>whereEmailRouterState<U>: FromRef<S>,- U: EmailService,- S: Send + Sync + 'static,-{- type Rejection = EmailLinkErr;-- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let Cached(MacroUserExtractor { macro_user_id, .. }) =- parts.extract_with_state(state).await?;- let links = <EmailRouterState<U>>::from_ref(state)- .inner- .get_inboxes_for_macro_id(macro_user_id)- .await?;- Ok(Self(links, PhantomData))- }-}--/// Macro-authorized extractor that resolves every inbox the caller can read.-///-/// This is the authorization-service equivalent of [`MultiEmailLinkExtractor`].-/// A caller with no inboxes receives an empty `Vec` rather than a rejection.-pub struct MultiEmailLinkExtractorV2<U, Auth>(pub Vec<Link>, pub PhantomData<(U, Auth)>);--impl<U, Auth> Clone for MultiEmailLinkExtractorV2<U, Auth> {- fn clone(&self) -> Self {- Self(self.0.clone(), PhantomData)- }-}--impl<S, U, Auth> FromRequestParts<S> for MultiEmailLinkExtractorV2<U, Auth>-where- EmailRouterState<U>: FromRef<S>,- U: EmailService,MacroAuthorizationState<Auth>: FromRef<S>,+ U: EmailService,Auth: MacroAuthorizationService,S: Send + Sync + 'static,{type Rejection = EmailLinkErr;async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let MacroAuthorizationExtractor { macro_user_id, .. } =- parts.extract_with_state(state).await?;+ let Cached(MacroAuthorizationExtractor { macro_user_id, .. }) = parts+ .extract_with_state(state)+ .await+ .map_err(EmailLinkErr::Authorization)?;let links = <EmailRouterState<U>>::from_ref(state).inner.get_inboxes_for_macro_id(macro_user_id)@@ -246,38 +217,6 @@ where}}-/// Extractor that returns `Option<Link>` - returns `None` if no link is found-/// instead of failing with a 404 error.-pub struct OptionalEmailLinkExtractor<U>(pub Option<Link>, pub PhantomData<U>);--impl<U> Clone for OptionalEmailLinkExtractor<U> {- fn clone(&self) -> Self {- Self(self.0.clone(), PhantomData)- }-}--impl<S, U> FromRequestParts<S> for OptionalEmailLinkExtractor<U>-where- EmailRouterState<U>: FromRef<S>,- U: EmailService,- S: Send + Sync + 'static,-{- type Rejection = EmailLinkErr;-- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let Cached(MacroUserExtractor {- macro_user_id,- user_context,- ..- }) = parts.extract_with_state(state).await?;- let res = <EmailRouterState<U>>::from_ref(state)- .inner- .get_link_by_auth_id_and_macro_id(&user_context.fusion_user_id, macro_user_id)- .await?;- Ok(Self(res, PhantomData))- }-}-/// Axum state wrapper for a [`GmailTokenProvider`] implementation.pub struct GmailTokenState<T> {pub(crate) inner: Arc<T>,@@ -299,67 +238,3 @@ impl<T> GmailTokenState<T> {}}}--/// Extractor that resolves the user's email link and fetches a Gmail access token.-pub struct GmailAccessTokenExtractor<U, V> {- /// The fetched Gmail OAuth access token.- pub access_token: String,- /// The email link used to fetch the token.- pub link: Link,- _phantom: PhantomData<(U, V)>,-}--/// Errors from [`GmailAccessTokenExtractor`].-#[derive(Debug, Error)]-pub enum GmailAccessTokenErr {- /// Failed to resolve the email link.- #[error(transparent)]- Link(#[from] EmailLinkErr),- /// Failed to fetch the Gmail access token.- #[error("Failed to fetch Gmail access token")]- TokenFetch(#[source] EmailErr),-}--impl IntoResponse for GmailAccessTokenErr {- fn into_response(self) -> Response {- match self {- GmailAccessTokenErr::Link(e) => e.into_response(),- GmailAccessTokenErr::TokenFetch(e) => {- tracing::error!(error=?e, "gmail token fetch error");- (- StatusCode::INTERNAL_SERVER_ERROR,- "Failed to fetch Gmail access token",- )- .into_response()- }- }- }-}--impl<S, U, V> FromRequestParts<S> for GmailAccessTokenExtractor<U, V>-where- EmailRouterState<U>: FromRef<S>,- GmailTokenState<V>: FromRef<S>,- U: EmailService,- V: GmailTokenProvider,- S: Send + Sync + 'static,-{- type Rejection = GmailAccessTokenErr;-- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {- let Cached(EmailLinkExtractor(link, _)) = parts- .extract_with_state::<Cached<EmailLinkExtractor<U>>, S>(state)- .await?;- let token_state = <GmailTokenState<V>>::from_ref(state);- let token = token_state- .inner- .fetch_gmail_access_token(&link)- .await- .map_err(GmailAccessTokenErr::TokenFetch)?;- Ok(Self {- access_token: token,- link,- _phantom: PhantomData,- })- }-}diff --git a/crates/email/src/inbound/axum/axum_impls/test.rs b/crates/email/src/inbound/axum/axum_impls/test.rsindex 82762a1548..d929386655 100644--- a/crates/email/src/inbound/axum/axum_impls/test.rs+++ b/crates/email/src/inbound/axum/axum_impls/test.rs@@ -1,4 +1,4 @@-use super::{EmailLinkErr, MultiEmailLinkExtractorV2, resolve_target_link};+use super::{EmailLinkErr, MultiEmailLinkExtractor, resolve_target_link};use crate::domain::models::{Link, UserProvider};use axum::{body::to_bytes, http::StatusCode, response::IntoResponse};use chrono::Utc;@@ -42,10 +42,10 @@ async fn authorization_error_delegates_response() {}#[test]-fn multi_email_link_extractor_v2_is_cloneable_without_generic_clone_bounds() {+fn multi_email_link_extractor_is_cloneable_without_generic_clone_bounds() {struct NotClone;- let extractor = MultiEmailLinkExtractorV2::<NotClone, NotClone>(Vec::new(), PhantomData);+ let extractor = MultiEmailLinkExtractor::<NotClone, NotClone>(Vec::new(), PhantomData);let _clone = extractor.clone();}diff --git a/crates/email/src/inbound/axum/draft_router.rs b/crates/email/src/inbound/axum/draft_router.rsindex 7796900588..cf640c97ce 100644--- a/crates/email/src/inbound/axum/draft_router.rs+++ b/crates/email/src/inbound/axum/draft_router.rs@@ -1,5 +1,6 @@use axum::{Json, Router, extract::State, http::StatusCode, response::IntoResponse, routing::post};use axum_extra::extract::Cached;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use thiserror::Error;@@ -12,14 +13,15 @@ use super::{};/// Create the draft router with a `POST /` handler.-pub fn draft_router<S, T>(state: EmailRouterState<T>) -> Router<S>+pub fn draft_router<S, T, Auth>() -> Router<S>where- S: Send + Sync + 'static,+ S: Send + Sync + Clone + 'static,T: EmailService,+ Auth: MacroAuthorizationService,+ EmailRouterState<T>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{- Router::new()- .route("/", post(create_draft_handler::<T>))- .with_state(state)+ Router::new().route("/", post(create_draft_handler::<T, Auth>))}/// Errors from the create draft handler.@@ -87,10 +89,12 @@ impl From<EmailErr> for CreateDraftError {))]#[tracing::instrument(err, skip(state, link, accessible_inboxes, body))]-pub async fn create_draft_handler<T: EmailService>(+pub async fn create_draft_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T>>,- Cached(MultiEmailLinkExtractor(accessible_inboxes, _)): Cached<MultiEmailLinkExtractor<T>>,+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T, Auth>>,+ Cached(MultiEmailLinkExtractor(accessible_inboxes, _)): Cached<+ MultiEmailLinkExtractor<T, Auth>,+ >,Json(body): Json<CreateDraftRequest>,) -> Result<impl IntoResponse, CreateDraftError> {let input = body.into_domain();diff --git a/crates/email/src/inbound/axum/email_filter_router.rs b/crates/email/src/inbound/axum/email_filter_router.rsindex af49b372cd..46c604dc41 100644--- a/crates/email/src/inbound/axum/email_filter_router.rs+++ b/crates/email/src/inbound/axum/email_filter_router.rs@@ -7,6 +7,7 @@ use axum::{};use axum_extra::extract::Cached;use chrono::{DateTime, Utc};+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use thiserror::Error;use uuid::Uuid;@@ -116,16 +117,18 @@ impl From<EmailErr> for EmailFilterError {// ── Router ───────────────────────────────────────────────────────────/// Create the email filter router with `PUT /`, `DELETE /{id}`, and `GET /` handlers.-pub fn email_filter_router<S, T>() -> Router<S>+pub fn email_filter_router<S, T, Auth>() -> Router<S>whereS: Send + Sync + Clone + 'static,T: EmailService,+ Auth: MacroAuthorizationService,EmailRouterState<T>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{Router::new()- .route("/", put(upsert_email_filter_handler::<T>))- .route("/", get(list_email_filters_handler::<T>))- .route("/{id}", delete(delete_email_filter_handler::<T>))+ .route("/", put(upsert_email_filter_handler::<T, Auth>))+ .route("/", get(list_email_filters_handler::<T, Auth>))+ .route("/{id}", delete(delete_email_filter_handler::<T, Auth>))}// ── Handlers ─────────────────────────────────────────────────────────@@ -145,9 +148,9 @@ where))]#[tracing::instrument(err, skip(state, link, body))]-pub async fn upsert_email_filter_handler<T: EmailService>(+pub async fn upsert_email_filter_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T>>,+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T, Auth>>,Json(body): Json<UpsertEmailFilterRequest>,) -> Result<Json<UpsertEmailFilterResponse>, EmailFilterError> {let input = UpsertEmailFilterInput {@@ -180,9 +183,9 @@ pub async fn upsert_email_filter_handler<T: EmailService>())]#[tracing::instrument(err, skip(state, link))]-pub async fn delete_email_filter_handler<T: EmailService>(+pub async fn delete_email_filter_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T>>,+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T, Auth>>,Path(filter_id): Path<Uuid>,) -> Result<impl IntoResponse, EmailFilterError> {let deleted = state.inner.delete_email_filter(&link, filter_id).await?;@@ -209,9 +212,9 @@ pub async fn delete_email_filter_handler<T: EmailService>())]#[tracing::instrument(err, skip_all)]-pub async fn list_email_filters_handler<T: EmailService>(+pub async fn list_email_filters_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T>>,+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T, Auth>>,) -> Result<Json<ListEmailFiltersResponse>, EmailFilterError> {let filters = state.inner.list_email_filters(&link).await?;diff --git a/crates/email/src/inbound/axum/get_thread_router.rs b/crates/email/src/inbound/axum/get_thread_router.rsindex 236162dc94..58e944f268 100644--- a/crates/email/src/inbound/axum/get_thread_router.rs+++ b/crates/email/src/inbound/axum/get_thread_router.rs@@ -10,6 +10,7 @@ use axum::{use entity_access::domain::models::{EntityPermission, ViewAccessLevel};use entity_access::domain::ports::EntityAccessService;use entity_access::inbound::axum_extractors::ThreadAccessLevelExtractor;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use thiserror::Error;@@ -22,34 +23,43 @@ const DEFAULT_MESSAGE_LIMIT: i64 = 5;/// The maximum number of messages that can be returned per request.const MESSAGE_MAX: i64 = 100;-pub struct EmailThreadRouterState<T, Svc> {+pub struct EmailThreadRouterState<T, Svc, Auth> {pub service: Arc<T>,pub access_service: Arc<Svc>,+ pub authorization_state: MacroAuthorizationState<Auth>,}-impl<T, Svc> Clone for EmailThreadRouterState<T, Svc> {+impl<T, Svc, Auth> Clone for EmailThreadRouterState<T, Svc, Auth> {fn clone(&self) -> Self {Self {service: self.service.clone(),access_service: self.access_service.clone(),+ authorization_state: self.authorization_state.clone(),}}}-impl<T, Svc> FromRef<EmailThreadRouterState<T, Svc>> for Arc<Svc> {- fn from_ref(state: &EmailThreadRouterState<T, Svc>) -> Self {+impl<T, Svc, Auth> FromRef<EmailThreadRouterState<T, Svc, Auth>> for Arc<Svc> {+ fn from_ref(state: &EmailThreadRouterState<T, Svc, Auth>) -> Self {state.access_service.clone()}}-pub fn thread_router<S, T, Svc>(state: EmailThreadRouterState<T, Svc>) -> Router<S>+impl<T, Svc, Auth> FromRef<EmailThreadRouterState<T, Svc, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &EmailThreadRouterState<T, Svc, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++pub fn thread_router<S, T, Svc, Auth>(state: EmailThreadRouterState<T, Svc, Auth>) -> Router<S>whereS: Send + Sync + 'static,T: EmailService,Svc: EntityAccessService,+ Auth: MacroAuthorizationService,{Router::new()- .route("/{thread_id}", get(get_thread_handler::<T, Svc>))+ .route("/{thread_id}", get(get_thread_handler::<T, Svc, Auth>)).with_state(state)}@@ -106,9 +116,13 @@ impl IntoResponse for GetThreadError {))]#[tracing::instrument(err, skip(state, access))]-pub async fn get_thread_handler<T: EmailService, Svc: EntityAccessService>(- State(state): State<EmailThreadRouterState<T, Svc>>,- access: ThreadAccessLevelExtractor<ViewAccessLevel, Svc>,+pub async fn get_thread_handler<+ T: EmailService,+ Svc: EntityAccessService,+ Auth: MacroAuthorizationService,+>(+ State(state): State<EmailThreadRouterState<T, Svc, Auth>>,+ access: ThreadAccessLevelExtractor<ViewAccessLevel, Svc, Auth>,extract::Query(params): extract::Query<GetThreadParams>,) -> Result<Json<GetThreadResponse>, GetThreadError> {let (offset, limit) = parse_pagination_params(¶ms)?;diff --git a/crates/email/src/inbound/axum/list_labels_router.rs b/crates/email/src/inbound/axum/list_labels_router.rsindex bec619d617..8bbfbea958 100644--- a/crates/email/src/inbound/axum/list_labels_router.rs+++ b/crates/email/src/inbound/axum/list_labels_router.rs@@ -1,5 +1,6 @@use axum::{Json, Router, extract::State, http::StatusCode, response::IntoResponse, routing::get};use axum_extra::extract::Cached;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use thiserror::Error;@@ -44,13 +45,15 @@ impl From<EmailErr> for ListLabelsError {}/// Create the list labels router with a `GET /` handler.-pub fn list_labels_router<S, T>() -> Router<S>+pub fn list_labels_router<S, T, Auth>() -> Router<S>whereS: Send + Sync + Clone + 'static,T: EmailService,+ Auth: MacroAuthorizationService,EmailRouterState<T>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{- Router::new().route("/", get(list_labels_handler::<T>))+ Router::new().route("/", get(list_labels_handler::<T, Auth>))}/// List all labels for the user's email link.@@ -66,9 +69,9 @@ where))]#[tracing::instrument(err, skip_all)]-pub async fn list_labels_handler<T: EmailService>(+pub async fn list_labels_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(MultiEmailLinkExtractor(links, _)): Cached<MultiEmailLinkExtractor<T>>,+ Cached(MultiEmailLinkExtractor(links, _)): Cached<MultiEmailLinkExtractor<T, Auth>>,) -> Result<Json<ListLabelsResponse>, ListLabelsError> {let mut labels = Vec::new();for link in &links {diff --git a/crates/email/src/inbound/axum/previews_router.rs b/crates/email/src/inbound/axum/previews_router.rsindex 4988052e46..ce7721cd1f 100644--- a/crates/email/src/inbound/axum/previews_router.rs+++ b/crates/email/src/inbound/axum/previews_router.rs@@ -4,8 +4,10 @@ use axum::{routing::get,};use axum_extra::extract::Cached;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState,+};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use models_pagination::{CursorOptionExt, CursorWithValAndFilter, SimpleSortMethod, TypeEraseCursor,};@@ -51,14 +53,15 @@ where}}-pub fn router<S, T>(state: EmailRouterState<T>) -> Router<S>+pub fn router<S, T, Auth>() -> Router<S>where- S: Send + Sync,+ S: Send + Sync + Clone + 'static,T: EmailService,+ Auth: MacroAuthorizationService,+ EmailRouterState<T>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{- Router::new()- .route("/cursor/{view}", get(cursor_handler))- .with_state(state)+ Router::new().route("/cursor/{view}", get(cursor_handler::<T, Auth>))}/// Get paginated thread previews with cursor-based pagination.@@ -80,10 +83,10 @@ where))]#[tracing::instrument(skip(links, macro_user, service), fields(user_id=macro_user.macro_user_id.as_ref(), fusionauth_user_id=macro_user.user_context.fusion_user_id))]-async fn cursor_handler<T: EmailService>(+async fn cursor_handler<T: EmailService, Auth: MacroAuthorizationService>(State(service): State<EmailRouterState<T>>,- Cached(macro_user): Cached<MacroUserExtractor>,- Cached(MultiEmailLinkExtractor(links, _)): Cached<MultiEmailLinkExtractor<T>>,+ Cached(macro_user): Cached<MacroAuthorizationExtractor<Auth>>,+ Cached(MultiEmailLinkExtractor(links, _)): Cached<MultiEmailLinkExtractor<T, Auth>>,PreviewViewPathExtractor(preview_view): PreviewViewPathExtractor,extract::Query(params): extract::Query<GetPreviewsCursorParams>,cursor: Option<CursorWithValAndFilter<Uuid, SimpleSortMethod, ()>>,diff --git a/crates/email/src/inbound/axum/send_router.rs b/crates/email/src/inbound/axum/send_router.rsindex da1ffb748a..0c9153ece7 100644--- a/crates/email/src/inbound/axum/send_router.rs+++ b/crates/email/src/inbound/axum/send_router.rs@@ -1,5 +1,6 @@use axum::{Json, Router, extract::State, http::StatusCode, response::IntoResponse, routing::post};use axum_extra::extract::Cached;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};use model_error_response::ErrorResponse;use thiserror::Error;@@ -12,14 +13,15 @@ use super::{};/// Create the send router with a `POST /` handler.-pub fn send_router<S, T>(state: EmailRouterState<T>) -> Router<S>+pub fn send_router<S, T, Auth>() -> Router<S>where- S: Send + Sync + 'static,+ S: Send + Sync + Clone + 'static,T: EmailService,+ Auth: MacroAuthorizationService,+ EmailRouterState<T>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{- Router::new()- .route("/", post(send_message_handler::<T>))- .with_state(state)+ Router::new().route("/", post(send_message_handler::<T, Auth>))}/// Errors from the send message handler.@@ -87,10 +89,12 @@ impl From<EmailErr> for SendMessageError {))]#[tracing::instrument(err, skip(state, link, accessible_inboxes, body))]-pub async fn send_message_handler<T: EmailService>(+pub async fn send_message_handler<T: EmailService, Auth: MacroAuthorizationService>(State(state): State<EmailRouterState<T>>,- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T>>,- Cached(MultiEmailLinkExtractor(accessible_inboxes, _)): Cached<MultiEmailLinkExtractor<T>>,+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<T, Auth>>,+ Cached(MultiEmailLinkExtractor(accessible_inboxes, _)): Cached<+ MultiEmailLinkExtractor<T, Auth>,+ >,Json(body): Json<SendMessageRequest>,) -> Result<impl IntoResponse, SendMessageError> {let input = body.into_domain();diff --git a/crates/email/src/inbound/axum/thread_labels_router.rs b/crates/email/src/inbound/axum/thread_labels_router.rsindex 7d7cc29e70..11a48d9811 100644--- a/crates/email/src/inbound/axum/thread_labels_router.rs+++ b/crates/email/src/inbound/axum/thread_labels_router.rs@@ -6,8 +6,10 @@ use axum::{routing::patch,};use axum_extra::extract::Cached;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState,+};use model_error_response::ErrorResponse;-use model_user::axum_extractor::MacroUserExtractor;use thiserror::Error;use uuid::Uuid;@@ -81,15 +83,20 @@ impl From<EmailErr> for UpdateThreadLabelError {}/// Create the thread labels router with a `PATCH /{id}/labels` handler.-pub fn thread_labels_router<S, T, G>() -> Router<S>+pub fn thread_labels_router<S, T, G, Auth>() -> Router<S>whereS: Send + Sync + Clone + 'static,T: EmailService,G: GmailTokenProvider,+ Auth: MacroAuthorizationService,EmailRouterState<T>: axum::extract::FromRef<S>,GmailTokenState<G>: axum::extract::FromRef<S>,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<S>,{- Router::new().route("/{id}/labels", patch(update_thread_labels_handler::<T, G>))+ Router::new().route(+ "/{id}/labels",+ patch(update_thread_labels_handler::<T, G, Auth>),+ )}/// Add or remove a label from all messages in a thread.@@ -111,10 +118,14 @@ where))]#[tracing::instrument(err, skip(state, token_state, macro_user, body))]-pub async fn update_thread_labels_handler<T: EmailService, G: GmailTokenProvider>(+pub async fn update_thread_labels_handler<+ T: EmailService,+ G: GmailTokenProvider,+ Auth: MacroAuthorizationService,+>(State(state): State<EmailRouterState<T>>,State(token_state): State<GmailTokenState<G>>,- Cached(macro_user): Cached<MacroUserExtractor>,+ Cached(macro_user): Cached<MacroAuthorizationExtractor<Auth>>,Path(thread_id): Path<Uuid>,Json(body): Json<UpdateThreadLabelRequest>,) -> Result<Json<UpdateThreadLabelsResponse>, UpdateThreadLabelError> {diff --git a/crates/email/src/inbound/axum/thread_project_router.rs b/crates/email/src/inbound/axum/thread_project_router.rsindex bac3ac73f5..f5f44c8d01 100644--- a/crates/email/src/inbound/axum/thread_project_router.rs+++ b/crates/email/src/inbound/axum/thread_project_router.rs@@ -4,8 +4,9 @@ use axum::{use entity_access::domain::models::EditAccessLevel;use entity_access::domain::ports::EntityAccessService;use entity_access::inbound::axum_extractors::{- ProjectBodyAccessLevelExtractor, ThreadAccessLevelExtractor,+ ProjectBodyAccessLevelExtractorV2, ThreadAccessLevelExtractor,};+use macro_authorization::MacroAuthorizationService;use model_error_response::ErrorResponse;use thiserror::Error;@@ -77,16 +78,19 @@ impl From<EmailErr> for UpdateThreadProjectError {}/// Create the thread project router with a `PATCH /{thread_id}/project` handler.-pub fn thread_project_router<S, T, Svc>(state: EmailThreadRouterState<T, Svc>) -> Router<S>+pub fn thread_project_router<S, T, Svc, Auth>(+ state: EmailThreadRouterState<T, Svc, Auth>,+) -> Router<S>whereS: Send + Sync + 'static,T: EmailService,Svc: EntityAccessService,+ Auth: MacroAuthorizationService,{Router::new().route("/{thread_id}/project",- patch(update_thread_project_handler::<T, Svc>),+ patch(update_thread_project_handler::<T, Svc, Auth>),).with_state(state)}@@ -109,17 +113,26 @@ where))]#[tracing::instrument(err, skip(state, access, project))]-pub async fn update_thread_project_handler<T: EmailService, Svc: EntityAccessService>(- State(state): State<EmailThreadRouterState<T, Svc>>,- access: ThreadAccessLevelExtractor<EditAccessLevel, Svc>,- project: ProjectBodyAccessLevelExtractor<EditAccessLevel, UpdateThreadProjectRequest, Svc>,+pub async fn update_thread_project_handler<+ T: EmailService,+ Svc: EntityAccessService,+ Auth: MacroAuthorizationService,+>(+ State(state): State<EmailThreadRouterState<T, Svc, Auth>>,+ access: ThreadAccessLevelExtractor<EditAccessLevel, Svc, Auth>,+ project: ProjectBodyAccessLevelExtractorV2<+ EditAccessLevel,+ UpdateThreadProjectRequest,+ Svc,+ Auth,+ >,) -> Result<Json<UpdateThreadProjectResponse>, UpdateThreadProjectError> {let project_receipt = match project {- ProjectBodyAccessLevelExtractor::FoundProject {+ ProjectBodyAccessLevelExtractorV2::FoundProject {entity_access_receipt,..} => Some(entity_access_receipt),- ProjectBodyAccessLevelExtractor::ProjectNotInBody { .. } => None,+ ProjectBodyAccessLevelExtractorV2::ProjectNotInBody { .. } => None,};let old_project_id = statediff --git a/crates/entity_access/src/inbound/axum_extractors/thread.rs b/crates/entity_access/src/inbound/axum_extractors/thread.rsindex 4a1f0c7cc3..868da91c97 100644--- a/crates/entity_access/src/inbound/axum_extractors/thread.rs+++ b/crates/entity_access/src/inbound/axum_extractors/thread.rs@@ -1,42 +1,49 @@//! Thread (email thread) access extractor.+#[cfg(test)]+mod test;+use std::collections::HashMap;use std::marker::PhantomData;use std::sync::Arc;use axum::{- Extension, RequestPartsExt,+ RequestPartsExt,extract::{FromRef, FromRequestParts, Path},http::request::Parts,};+use macro_authorization::{+ MacroAuthorizationService, MacroAuthorizationState, OptionalMacroAuthorizationExtractor,+};-use super::{ExtractorError, InternalUser, RequiredPermission};+use super::{ExtractorError, RequiredPermission};use crate::domain::{models::{AccessLevel, Entity, EntityAccessAuth, EntityAccessReceipt, EntityPermission, EntityType,},ports::EntityAccessService,};-use model_user::axum_extractor::OptionalMacroUserExtractor;-/// Validates that the user has at least the required access level to an email thread.////// Type parameter `T` specifies the required access level./// Type parameter `Svc` is the entity access service implementation.+/// Type parameter `Auth` is the authorization service implementation.////// Extracts the thread ID from the `thread_id` path parameter.#[derive(Debug)]-pub struct ThreadAccessLevelExtractor<T: RequiredPermission, Svc> {+pub struct ThreadAccessLevelExtractor<T: RequiredPermission, Svc, Auth> {/// The entity access receiptpub entity_access_receipt: EntityAccessReceipt<T>,- _marker: PhantomData<(T, Svc)>,+ _marker: PhantomData<(T, Svc, Auth)>,}-impl<T, S, Svc> FromRequestParts<S> for ThreadAccessLevelExtractor<T, Svc>+impl<T, S, Svc, Auth> FromRequestParts<S> for ThreadAccessLevelExtractor<T, Svc, Auth>whereT: RequiredPermission,Arc<Svc>: FromRef<S>,Svc: EntityAccessService,+ MacroAuthorizationState<Auth>: FromRef<S>,+ Auth: MacroAuthorizationService,S: Send + Sync + 'static,{type Rejection = ExtractorError;@@ -45,10 +52,13 @@ whereasync fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {let service = <Arc<Svc>>::from_ref(state);- let OptionalMacroUserExtractor { macro_user_id, .. } = parts- .extract()+ let OptionalMacroAuthorizationExtractor {+ macro_user_id,+ is_internal_access,+ ..+ } = OptionalMacroAuthorizationExtractor::<Auth>::from_request_parts(parts, state).await- .map_err(|_| ExtractorError::Internal)?;+ .map_err(ExtractorError::from)?;let Path(path_params): Path<HashMap<String, String>> = parts.extract()@@ -62,16 +72,7 @@ where))?.clone();- let internal_user: Option<Extension<InternalUser>> = if macro_user_id.is_none() {- parts- .extract()- .await- .map_err(|_| ExtractorError::Internal)?- } else {- None- };-- if internal_user.is_some() {+ if macro_user_id.is_none() && is_internal_access {return Ok(Self {entity_access_receipt: EntityAccessReceipt {entity: Entity {diff --git a/crates/entity_access/src/inbound/axum_extractors/thread/test.rs b/crates/entity_access/src/inbound/axum_extractors/thread/test.rsnew file mode 100644index 0000000000..82904166d5--- /dev/null+++ b/crates/entity_access/src/inbound/axum_extractors/thread/test.rs@@ -0,0 +1,350 @@+use std::sync::Arc;++use axum::{+ Router,+ body::{Body, to_bytes},+ extract::FromRef,+ http::{Request, StatusCode, header},+ routing::get,+};+use macro_authorization::{+ INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,+ MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,+};+use model_user::UserContext;+use rootcause::Report;+use tower::ServiceExt;++use super::*;+use crate::{+ domain::models::{EditAccessLevel, EntityAccessAuth, ViewAccessLevel},+ inbound::axum_extractors::test_support::{+ AccessCall, FakeEntityAccessService, INTERNAL_KEY, USER_ID,+ },+};++const THREAD_ID: &str = "thread-1";+const DEFAULT_INTERNAL_USER_ID: &str = "macro|[email protected]";+const NORMALIZED_DEFAULT_INTERNAL_USER_ID: &str = "macro|[email protected]";++type ViewExtractor =+ ThreadAccessLevelExtractor<ViewAccessLevel, FakeEntityAccessService, FakeAuthorizationService>;+type EditExtractor =+ ThreadAccessLevelExtractor<EditAccessLevel, FakeEntityAccessService, FakeAuthorizationService>;++#[derive(Clone, Debug, Default)]+struct FakeAuthorizationService {+ default_internal_user_id: Option<String>,+}++impl FakeAuthorizationService {+ fn with_default_internal_user() -> Self {+ Self {+ default_internal_user_id: Some(DEFAULT_INTERNAL_USER_ID.to_string()),+ }+ }+}++impl MacroAuthorizationService for FakeAuthorizationService {+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {+ match jwt {+ "valid" => Ok(user_context(USER_ID)),+ "expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),+ _ => 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+ .or_else(|| self.default_internal_user_id.clone())+ .map(|user_id| user_context(&user_id)))+ }+}++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,+ }+}++#[derive(Clone)]+struct TestState {+ entity_access: Arc<FakeEntityAccessService>,+ authorization: MacroAuthorizationState<FakeAuthorizationService>,+}++impl TestState {+ fn new(access_level: Option<AccessLevel>) -> Self {+ Self::with_authorization(access_level, FakeAuthorizationService::default())+ }++ fn with_authorization(+ access_level: Option<AccessLevel>,+ authorization: FakeAuthorizationService,+ ) -> Self {+ Self {+ entity_access: Arc::new(FakeEntityAccessService::new(access_level)),+ authorization: MacroAuthorizationState::new(Arc::new(authorization)),+ }+ }+}++impl FromRef<TestState> for Arc<FakeEntityAccessService> {+ fn from_ref(state: &TestState) -> Self {+ state.entity_access.clone()+ }+}++impl FromRef<TestState> for MacroAuthorizationState<FakeAuthorizationService> {+ fn from_ref(state: &TestState) -> Self {+ state.authorization.clone()+ }+}++async fn view_handler(access: ViewExtractor) -> &'static str {+ receipt_auth_name(access.entity_access_receipt.auth())+}++async fn edit_handler(access: EditExtractor) -> &'static str {+ receipt_auth_name(access.entity_access_receipt.auth())+}++fn receipt_auth_name(auth: &EntityAccessAuth) -> &'static str {+ match auth {+ EntityAccessAuth::Authenticated(_) => "authenticated",+ EntityAccessAuth::Unauthenticated => "unauthenticated",+ EntityAccessAuth::Internal => "internal",+ EntityAccessAuth::Bot(_) => "bot",+ }+}++fn view_router(state: TestState) -> Router {+ Router::new()+ .route("/threads/{thread_id}", get(view_handler))+ .with_state(state)+}++fn edit_router(state: TestState) -> Router {+ Router::new()+ .route("/threads/{thread_id}", get(edit_handler))+ .with_state(state)+}++fn request() -> axum::http::request::Builder {+ Request::get(format!("/threads/{THREAD_ID}"))+}++async fn response_body(response: axum::response::Response) -> String {+ let body = to_bytes(response.into_body(), usize::MAX)+ .await+ .expect("response body should be readable");+ String::from_utf8(body.to_vec()).expect("response body should be UTF-8")+}++fn expected_call(user_id: Option<&str>) -> AccessCall {+ AccessCall {+ user_id: user_id.map(str::to_string),+ entity_id: THREAD_ID.to_string(),+ entity_type: EntityType::EmailThread,+ }+}++#[tokio::test]+async fn anonymous_public_access_returns_unauthenticated_receipt() {+ let state = TestState::new(Some(AccessLevel::View));+ let response = view_router(state.clone())+ .oneshot(request().body(Body::empty()).unwrap())+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response_body(response).await, "unauthenticated");+ assert_eq!(state.entity_access.calls(), [expected_call(None)]);+}++#[tokio::test]+async fn anonymous_access_without_public_grant_is_rejected() {+ let state = TestState::new(None);+ let response = view_router(state.clone())+ .oneshot(request().body(Body::empty()).unwrap())+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(state.entity_access.calls(), [expected_call(None)]);+}++#[tokio::test]+async fn insufficient_public_access_is_rejected() {+ let state = TestState::new(Some(AccessLevel::View));+ let response = edit_router(state.clone())+ .oneshot(request().body(Body::empty()).unwrap())+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(state.entity_access.calls(), [expected_call(None)]);+}++#[tokio::test]+async fn authenticated_access_uses_the_users_acl() {+ let state = TestState::new(Some(AccessLevel::View));+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response_body(response).await, "authenticated");+ assert_eq!(state.entity_access.calls(), [expected_call(Some(USER_ID))]);+}++#[tokio::test]+async fn authenticated_access_with_insufficient_permission_is_rejected() {+ let state = TestState::new(Some(AccessLevel::View));+ let response = edit_router(state.clone())+ .oneshot(+ request()+ .header(header::AUTHORIZATION, "Bearer valid")+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(state.entity_access.calls(), [expected_call(Some(USER_ID))]);+}++#[tokio::test]+async fn identity_free_internal_access_receives_owner_without_acl_lookup() {+ let state = TestState::new(None);+ let response = edit_router(state.clone())+ .oneshot(+ request()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response_body(response).await, "internal");+ assert!(state.entity_access.calls().is_empty());+}++#[tokio::test]+async fn internal_acting_user_uses_the_users_acl() {+ let state = TestState::new(Some(AccessLevel::View));+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .header(INTERNAL_MACRO_USER_ID_HEADER, USER_ID)+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response_body(response).await, "authenticated");+ assert_eq!(state.entity_access.calls(), [expected_call(Some(USER_ID))]);+}++#[tokio::test]+async fn default_internal_user_uses_the_users_acl() {+ let state = TestState::with_authorization(+ Some(AccessLevel::View),+ FakeAuthorizationService::with_default_internal_user(),+ );+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(INTERNAL_API_KEY_HEADER, INTERNAL_KEY)+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response_body(response).await, "authenticated");+ assert_eq!(+ state.entity_access.calls(),+ [expected_call(Some(NORMALIZED_DEFAULT_INTERNAL_USER_ID))]+ );+}++#[tokio::test]+async fn invalid_internal_key_is_rejected_without_anonymous_fallback() {+ let state = TestState::new(Some(AccessLevel::Owner));+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(INTERNAL_API_KEY_HEADER, "invalid")+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert!(state.entity_access.calls().is_empty());+}++#[tokio::test]+async fn invalid_jwt_is_rejected_without_anonymous_fallback() {+ let state = TestState::new(Some(AccessLevel::Owner));+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(header::AUTHORIZATION, "Bearer invalid")+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert!(state.entity_access.calls().is_empty());+}++#[tokio::test]+async fn expired_jwt_is_rejected_without_anonymous_fallback() {+ let state = TestState::new(Some(AccessLevel::Owner));+ let response = view_router(state.clone())+ .oneshot(+ request()+ .header(header::AUTHORIZATION, "Bearer expired")+ .body(Body::empty())+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(+ response_body(response).await,+ r#"{"message":"jwt expired"}"#+ );+ assert!(state.entity_access.calls().is_empty());+}diff --git a/crates/graphql_soup/src/resolvers.rs b/crates/graphql_soup/src/resolvers.rsindex 6e6b0636f6..e49db8f2d4 100644--- a/crates/graphql_soup/src/resolvers.rs+++ b/crates/graphql_soup/src/resolvers.rs@@ -5,7 +5,7 @@ use axum::extract::FromRef;use axum_extra::extract::Cached;use email::{domain::ports::EmailService,- inbound::axum::{axum_impls::MultiEmailLinkExtractorV2, previews_router::EmailRouterState},+ inbound::axum::{axum_impls::MultiEmailLinkExtractor, previews_router::EmailRouterState},};use entity_access::{domain::{models::MemberTeamRole, ports::EntityAccessService},@@ -65,8 +65,8 @@ whereEdges: SoupEntityEdges,{let macro_user_id = require_authorized_user::<Auth, St>(ctx).await?;- let Cached(MultiEmailLinkExtractorV2(links, _)) =- extract_part::<Cached<MultiEmailLinkExtractorV2<E, Auth>>, St>(ctx).await?;+ let Cached(MultiEmailLinkExtractor(links, _)) =+ extract_part::<Cached<MultiEmailLinkExtractor<E, Auth>>, St>(ctx).await?;let link_ids = links.into_iter().map(|link| link.id).collect();let request = input.into_request(macro_user_id, link_ids)?;diff --git a/services/document_storage_service/src/api/threads/edit_thread.rs b/services/document_storage_service/src/api/threads/edit_thread.rsindex 003bfbca99..bc1ab6cfbd 100644--- a/services/document_storage_service/src/api/threads/edit_thread.rs+++ b/services/document_storage_service/src/api/threads/edit_thread.rs@@ -50,7 +50,11 @@ pub struct PatchThreadRequestV2 {)]#[tracing::instrument(skip(ctx, user, project, thread_access), fields(user_id=?user.macro_user_id))]pub async fn edit_thread_handler(- thread_access: ThreadAccessLevelExtractor<OwnerAccessLevel, EntityAccessService>,+ thread_access: ThreadAccessLevelExtractor<+ OwnerAccessLevel,+ EntityAccessService,+ AuthorizationService,+ >,State(ctx): State<ApiContext>,user: MacroAuthorizationExtractor<AuthorizationService>,thread_context: Extension<EmailThreadPermission>,diff --git a/services/email_service/Cargo.toml b/services/email_service/Cargo.tomlindex 01607e6630..ee03a40ba6 100644--- a/services/email_service/Cargo.toml+++ b/services/email_service/Cargo.toml@@ -111,6 +111,7 @@ infer = "0.19.0"item_filters = { path = "../../crates/item_filters" }lol_html = { workspace = true }macro_auth = { path = "../../crates/macro_auth" }+macro_authorization = { path = "../../crates/macro_authorization" }macro_cors = { path = "../../crates/macro_cors" }macro_config = { path = "../../crates/macro_config" }macro_db_client = { path = "../../crates/macro_db_client" }diff --git a/services/email_service/src/api/context.rs b/services/email_service/src/api/context.rsindex 350ceaee10..56a6a9408f 100644--- a/services/email_service/src/api/context.rs+++ b/services/email_service/src/api/context.rs@@ -16,11 +16,15 @@ use entity_access_management::domain::service::EntityAccessManagementServiceImpluse frecency::{domain::services::FrecencyQueryServiceImpl, outbound::postgres::FrecencyPgStorage};use macro_auth::InternalApiKey;use macro_auth::middleware::decode_jwt::JwtValidationArgs;+use macro_authorization::{+ MacroAuthJwtValidator, MacroAuthorizationServiceImpl, MacroAuthorizationState,+};use macro_event_broker::{KafkaEventPublisher, MacroEventBrokerService};use static_file_service_client::StaticFileServiceClient;use std::sync::Arc;use system_properties::{PgSystemPropertiesRepository, SystemPropertiesServiceImpl};+pub(crate) type AuthorizationService = MacroAuthorizationServiceImpl<MacroAuthJwtValidator>;pub(crate) type EmailEntityAccessService = EntityAccessServiceImpl<PgAccessRepository>;pub(crate) type EmailEntityAccessManagementService =EntityAccessManagementServiceImpl<entity_access_management::outbound::PgRepository>;@@ -47,12 +51,14 @@ pub(crate) struct ApiContext {pub sfs_client: Arc<StaticFileServiceClient>,pub dss_client: Arc<DocumentStorageServiceClient>,pub system_properties_service: Arc<SystemPropertiesServiceImpl<PgSystemPropertiesRepository>>,+ pub authorization_state: MacroAuthorizationState<AuthorizationService>,pub jwt_args: JwtValidationArgs,pub config: Arc<Config>,pub internal_api_key: InternalApiKey,pub email_service: EmailRouterState<EmailSvc>,pub entity_access_service: Arc<EmailEntityAccessService>,- pub email_thread_state: EmailThreadRouterState<EmailSvc, EmailEntityAccessService>,+ pub email_thread_state:+ EmailThreadRouterState<EmailSvc, EmailEntityAccessService, AuthorizationService>,pub gmail_token_state: GmailTokenState<GmailTokenProviderImpl>,pub macro_event_broker: Arc<MacroEventBrokerService<KafkaEventPublisher>>,}diff --git a/services/email_service/src/api/email/attachments/get.rs b/services/email_service/src/api/email/attachments/get.rsindex f0c02a9096..fa11aaa14f 100644--- a/services/email_service/src/api/email/attachments/get.rs+++ b/services/email_service/src/api/email/attachments/get.rs@@ -1,12 +1,12 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use anyhow::Context;+use axum::Json;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};use cloudfront_sign::{SignedOptions, get_signed_url};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::email::service::attachment;use models_email::service;use std::time::{SystemTime, UNIX_EPOCH};@@ -36,28 +36,30 @@ pub struct GetAttachmentResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(attachment_id): Path<Uuid>,) -> Result<Response, Response> {// Resolve which of the caller's inboxes owns this attachment. Each inbox is a// distinct Google account, so the owning link also determines the Gmail token.- let links =- email_db_client::links::get::fetch_inboxes_for_macro_id(&ctx.db, &user_context.user_id)- .await- .map_err(|e| {- tracing::warn!(error=?e, "error fetching links");- (- StatusCode::INTERNAL_SERVER_ERROR,- Json(ErrorResponse {- message: "error fetching attachment".into(),- }),- )- .into_response()- })?;+ let links = email_db_client::links::get::fetch_inboxes_for_macro_id(+ &ctx.db,+ &authorization.user_context.user_id,+ )+ .await+ .map_err(|e| {+ tracing::warn!(error=?e, "error fetching links");+ (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(ErrorResponse {+ message: "error fetching attachment".into(),+ }),+ )+ .into_response()+ })?;let mut owned = None;for link in links {diff --git a/services/email_service/src/api/email/attachments/mod.rs b/services/email_service/src/api/email/attachments/mod.rsindex a2bada1de3..0ef65315c0 100644--- a/services/email_service/src/api/email/attachments/mod.rs+++ b/services/email_service/src/api/email/attachments/mod.rs@@ -18,7 +18,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {.layer(ServiceBuilder::new().layer(axum::middleware::from_fn_with_state(- state.email_service.clone(),+ state.clone(),crate::api::middleware::link::attach_link_context,)).layer(axum::middleware::from_fn_with_state(diff --git a/services/email_service/src/api/email/backfill/cancel.rs b/services/email_service/src/api/email/backfill/cancel.rsindex f166b83ddc..3c4b8fd2ad 100644--- a/services/email_service/src/api/email/backfill/cancel.rs+++ b/services/email_service/src/api/email/backfill/cancel.rs@@ -1,12 +1,12 @@-use crate::api::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::{Extension,extract::State,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::email::service::backfill::BackfillJobStatus;use models_email::email::service::link::Link;use sqlx::types::Uuid;@@ -31,10 +31,10 @@ pub struct CancelBackfillParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, link), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization, link), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,link: Extension<Link>,Json(req_body): Json<CancelBackfillParams>,) -> Result<Response, Response> {diff --git a/services/email_service/src/api/email/backfill/get.rs b/services/email_service/src/api/email/backfill/get.rsindex f1ce11f77a..cdf230c9ba 100644--- a/services/email_service/src/api/email/backfill/get.rs+++ b/services/email_service/src/api/email/backfill/get.rs@@ -1,12 +1,12 @@-use crate::api::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::extract::{Path, State};use axum::{Extension,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::email::service::backfill::BackfillJob;use models_email::email::service::link::Link;use sqlx::types::Uuid;@@ -36,10 +36,10 @@ pub struct GetBackfillJobResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, link), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization, link), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,link: Extension<Link>,Path(job_id): Path<Uuid>,) -> Result<Response, Response> {@@ -151,14 +151,14 @@ pub struct ListBackfillJobsResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn list_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, ListBackfillJobsError> {let jobs = email_db_client::backfill::job::get::get_all_jobs_by_fusionauth_user_id(&ctx.db,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await.map_err(ListBackfillJobsError::QueryError)?;diff --git a/services/email_service/src/api/email/backfill/mod.rs b/services/email_service/src/api/email/backfill/mod.rsindex 3f5eeb2307..6e6b142ab5 100644--- a/services/email_service/src/api/email/backfill/mod.rs+++ b/services/email_service/src/api/email/backfill/mod.rs@@ -13,7 +13,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {.route("/gmail/{id}", get(get::handler)).route("/gmail/active", get(get::active_handler)).layer(axum::middleware::from_fn_with_state(- state.email_service,+ state.clone(),crate::api::middleware::link::attach_link_context,));diff --git a/services/email_service/src/api/email/contacts/list.rs b/services/email_service/src/api/email/contacts/list.rsindex 42b578645f..cdc5082aa7 100644--- a/services/email_service/src/api/email/contacts/list.rs+++ b/services/email_service/src/api/email/contacts/list.rs@@ -1,10 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use axum::Json;use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::email::service::address::ContactInfoWithInteraction;use sqlx::types::Uuid;use std::collections::HashMap;@@ -29,24 +29,26 @@ pub struct ListContactsResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn list_contacts_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, Response> {- let links =- email_db_client::links::get::fetch_inboxes_for_macro_id(&ctx.db, &user_context.user_id)- .await- .map_err(|e| {- tracing::error!(error=?e, "unable to fetch links");- (- StatusCode::INTERNAL_SERVER_ERROR,- Json(ErrorResponse {- message: "unable to fetch links".into(),- }),- )- .into_response()- })?;+ let links = email_db_client::links::get::fetch_inboxes_for_macro_id(+ &ctx.db,+ &authorization.user_context.user_id,+ )+ .await+ .map_err(|e| {+ tracing::error!(error=?e, "unable to fetch links");+ (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(ErrorResponse {+ message: "unable to fetch links".into(),+ }),+ )+ .into_response()+ })?;let mut contacts: HashMap<Uuid, Vec<ContactInfoWithInteraction>> =HashMap::with_capacity(links.len());diff --git a/services/email_service/src/api/email/contacts/mod.rs b/services/email_service/src/api/email/contacts/mod.rsindex fb8719a8ce..f9d3fa89c9 100644--- a/services/email_service/src/api/email/contacts/mod.rs+++ b/services/email_service/src/api/email/contacts/mod.rs@@ -14,14 +14,14 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {.route("/block",post(block_sender::handler).layer(axum::middleware::from_fn_with_state(- state.email_service.clone(),+ state.clone(),crate::api::middleware::link::attach_link_context,)),).route("/unblock",post(unblock_sender::handler).layer(axum::middleware::from_fn_with_state(- state.email_service.clone(),+ state.clone(),crate::api::middleware::link::attach_link_context,)),)diff --git a/services/email_service/src/api/email/drafts/mod.rs b/services/email_service/src/api/email/drafts/mod.rsindex 8a05649dec..4664cf8b2a 100644--- a/services/email_service/src/api/email/drafts/mod.rs+++ b/services/email_service/src/api/email/drafts/mod.rs@@ -12,7 +12,11 @@ use email::inbound::axum::draft_router::draft_router;pub fn router(state: ApiContext) -> Router<ApiContext> {Router::new()- .merge(draft_router(state.email_service.clone()))+ .merge(draft_router::<+ ApiContext,+ crate::api::context::EmailSvc,+ crate::api::context::AuthorizationService,+ >()).nest("/scheduled", scheduled::router()).route("/{id}", delete(delete::handler)).route("/{id}/attachments", post(add_attachment::handler))@@ -29,7 +33,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {delete(remove_forwarded_attachment::handler),).layer(axum::middleware::from_fn_with_state(- state.email_service,+ state.clone(),crate::api::middleware::link::attach_link_context,))}diff --git a/services/email_service/src/api/email/filters/mod.rs b/services/email_service/src/api/email/filters/mod.rsindex e5ee00104b..4be6779eea 100644--- a/services/email_service/src/api/email/filters/mod.rs+++ b/services/email_service/src/api/email/filters/mod.rs@@ -6,5 +6,6 @@ pub fn router() -> Router<ApiContext> {email::inbound::axum::email_filter_router::email_filter_router::<ApiContext,crate::api::context::EmailSvc,+ crate::api::context::AuthorizationService,>()}diff --git a/services/email_service/src/api/email/init.rs b/services/email_service/src/api/email/init.rsindex 53e0920d46..c891451e83 100644--- a/services/email_service/src/api/email/init.rs+++ b/services/email_service/src/api/email/init.rs@@ -1,4 +1,5 @@use crate::api::ApiContext;+use crate::api::context::AuthorizationService;use crate::utils::extract_email_with_response;use anyhow::Context;use authentication_service_client::error::AuthServiceClientError;@@ -13,10 +14,10 @@ use email::domain::ports::EmailRepo;use email::outbound::EmailPgRepo;use email_service::pubsub::publish_email_event;use email_utils::token_cache_key::TokenCacheKey;+use macro_authorization::MacroAuthorizationExtractor;use macro_user_id::email::EmailStr;use macro_user_id::user_id::MacroUserIdStr;use model::response::ErrorResponse;-use model::user::axum_extractor::MacroUserExtractor;use models_email::email::service::backfill::{BackfillJobStatus, BackfillOperation, BackfillPubsubMessage, InitPayload, JobScopedPayload,};@@ -191,16 +192,16 @@ pub struct InitParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_extractor), fields(user_id=user_extractor.user_context.user_id, fusionauth_user_id=user_extractor.user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,query: Query<InitParams>,- user_extractor: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, InitError> {// Init runs on every authentication, so its expected no-op outcomes (400s)// must not error-log. The span skips the auto err event and the result is// classified here, inside the span, where user fields still attach.- let result = init_user(ctx, query, user_extractor).await;+ let result = init_user(ctx, query, authorization).await;if let Err(e) = &result {let status = e.status_code();if status.is_server_error() {@@ -220,13 +221,10 @@ async fn init_user(link_id,force_share,}): Query<InitParams>,- user_extractor: MacroUserExtractor,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, InitError> {- let MacroUserExtractor {- macro_user_id,- user_context,- ..- } = user_extractor;+ let macro_user_id = authorization.macro_user_id;+ let user_context = authorization.user_context;tracing::info!(user_id = %user_context.user_id, ?link_id, "Init called");let pg_repo = EmailPgRepo::new(ctx.db.clone());diff --git a/services/email_service/src/api/email/labels/create.rs b/services/email_service/src/api/email/labels/create.rsindex 129b37c14b..729216179c 100644--- a/services/email_service/src/api/email/labels/create.rs+++ b/services/email_service/src/api/email/labels/create.rs@@ -1,10 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Response};use axum::{Extension, Json};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::service;use models_email::service::link::Link;use utoipa::ToSchema;@@ -36,10 +36,10 @@ pub struct CreateLabelResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, link, gmail_token), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization, link, gmail_token), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,link: Extension<Link>,gmail_token: Extension<String>,Json(request_body): Json<CreateLabelRequest>,diff --git a/services/email_service/src/api/email/labels/delete.rs b/services/email_service/src/api/email/labels/delete.rsindex 3b5a9628e7..ab7a36bd2a 100644--- a/services/email_service/src/api/email/labels/delete.rs+++ b/services/email_service/src/api/email/labels/delete.rs@@ -1,10 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};use axum::{Extension, Json};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::service::link::Link;use uuid::Uuid;@@ -25,10 +25,10 @@ use uuid::Uuid;(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, link), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization, link), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,link: Extension<Link>,Path(label_id): Path<Uuid>,) -> Result<Response, Response> {diff --git a/services/email_service/src/api/email/labels/mod.rs b/services/email_service/src/api/email/labels/mod.rsindex cab1a46f4d..9c7a760dbd 100644--- a/services/email_service/src/api/email/labels/mod.rs+++ b/services/email_service/src/api/email/labels/mod.rs@@ -10,6 +10,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {let hex_list_labels_routes = email::inbound::axum::list_labels_router::list_labels_router::<ApiContext,crate::api::context::EmailSvc,+ crate::api::context::AuthorizationService,>();Router::new()@@ -22,7 +23,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {).route("/{id}", delete(delete::handler)).layer(axum::middleware::from_fn_with_state(- state.email_service,+ state.clone(),crate::api::middleware::link::attach_link_context,)).merge(hex_list_labels_routes)diff --git a/services/email_service/src/api/email/links/delete.rs b/services/email_service/src/api/email/links/delete.rsindex c6490eee34..8290282b01 100644--- a/services/email_service/src/api/email/links/delete.rs+++ b/services/email_service/src/api/email/links/delete.rs@@ -1,12 +1,11 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use crate::api::email::links::access::{InboxAccess, InboxActionError, authorize_inbox_access};use anyhow::Context;-use axum::Extension;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::email::service::pubsub::{DeletionReason, LinkManagerMessage};use uuid::Uuid;@@ -31,12 +30,13 @@ use uuid::Uuid;(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn delete_link_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(link_id): Path<Uuid>,) -> Result<Response, InboxActionError> {+ let user_context = &authorization.user_context;let (link, access) = authorize_inbox_access(&ctx, &user_context.user_id, link_id).await?;match access {diff --git a/services/email_service/src/api/email/links/health_check.rs b/services/email_service/src/api/email/links/health_check.rsindex 852fc7a4dc..bf9f56a724 100644--- a/services/email_service/src/api/email/links/health_check.rs+++ b/services/email_service/src/api/email/links/health_check.rs@@ -1,13 +1,12 @@-use crate::api::context::ApiContext;-use axum::Extension;+use crate::api::context::{ApiContext, AuthorizationService};use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Json, Response};use email_service::util::gmail::auth::{fetch_token_or_mark_reauth_no_cache, is_reauth_required_error,};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::email::service::pubsub::LinkManagerMessage;use std::time::Duration;use thiserror::Error;@@ -56,15 +55,17 @@ impl IntoResponse for HealthCheckError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn health_check_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, HealthCheckError> {- let links =- email_db_client::links::get::fetch_inboxes_for_macro_id(&ctx.db, &user_context.user_id)- .await- .map_err(HealthCheckError::DatabaseError)?;+ let links = email_db_client::links::get::fetch_inboxes_for_macro_id(+ &ctx.db,+ &authorization.user_context.user_id,+ )+ .await+ .map_err(HealthCheckError::DatabaseError)?;for link in links {if !link.is_sync_active {diff --git a/services/email_service/src/api/email/links/list.rs b/services/email_service/src/api/email/links/list.rsindex e286c2af86..055bd24453 100644--- a/services/email_service/src/api/email/links/list.rs+++ b/services/email_service/src/api/email/links/list.rs@@ -1,11 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};+use axum::Json;use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};-use macro_user_id::user_id::MacroUserIdStr;+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::api;use utoipa::ToSchema;@@ -16,15 +15,12 @@ use thiserror::Error;pub enum ListLinksError {#[error("Database error")]DatabaseError(anyhow::Error),- #[error("Invalid macro user id")]- InvalidMacroId,}impl IntoResponse for ListLinksError {fn into_response(self) -> Response {let status_code = match &self {ListLinksError::DatabaseError(_) => StatusCode::INTERNAL_SERVER_ERROR,- ListLinksError::InvalidMacroId => StatusCode::BAD_REQUEST,};(status_code, self.to_string()).into_response()@@ -51,17 +47,17 @@ pub struct ListLinksResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn list_links_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,) -> Result<Response, ListLinksError> {- let macro_id = MacroUserIdStr::parse_from_str(&user_context.user_id)- .map_err(|_| ListLinksError::InvalidMacroId)?;-- let inboxes = email_db_client::links::get::fetch_inbox_details_for_macro_id(&ctx.db, ¯o_id)- .await- .map_err(ListLinksError::DatabaseError)?;+ let inboxes = email_db_client::links::get::fetch_inbox_details_for_macro_id(+ &ctx.db,+ &authorization.macro_user_id,+ )+ .await+ .map_err(ListLinksError::DatabaseError)?;let links = inboxes.into_iter()diff --git a/services/email_service/src/api/email/links/resync.rs b/services/email_service/src/api/email/links/resync.rsindex 29e20643aa..fe788fe502 100644--- a/services/email_service/src/api/email/links/resync.rs+++ b/services/email_service/src/api/email/links/resync.rs@@ -1,11 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use crate::api::email::links::access::{InboxActionError, authorize_inbox_access};use anyhow::Context;-use axum::Extension;use axum::extract::{Path, State};use axum::response::{IntoResponse, Json, Response};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::email::service::backfill::{BackfillJobStatus, BackfillOperation, BackfillPubsubMessage, InitPayload, JobScopedPayload,};@@ -42,13 +41,14 @@ pub struct ResyncResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn resync_link_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(link_id): Path<Uuid>,) -> Result<Response, InboxActionError> {- let (link, _access) = authorize_inbox_access(&ctx, &user_context.user_id, link_id).await?;+ let (link, _access) =+ authorize_inbox_access(&ctx, &authorization.user_context.user_id, link_id).await?;if let Some(active) =email_db_client::backfill::job::get::get_active_backfill_job(&ctx.db, link.id)diff --git a/services/email_service/src/api/email/messages/get.rs b/services/email_service/src/api/email/messages/get.rsindex 1cdada8360..0c4b1693c2 100644--- a/services/email_service/src/api/email/messages/get.rs+++ b/services/email_service/src/api/email/messages/get.rs@@ -1,12 +1,13 @@use crate::api::ApiContext;+use crate::api::context::AuthorizationService;use anyhow::Context;use axum::{- Extension,extract::{Path, State},http::StatusCode,response::{IntoResponse, Json, Response},};-use model::{response::ErrorResponse, user::UserContext};+use macro_authorization::MacroAuthorizationExtractor;+use model::response::ErrorResponse;use sqlx::types::Uuid;use std::collections::HashSet;use strum_macros::AsRefStr;@@ -78,10 +79,10 @@ pub struct PathParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(PathParams { id }): Path<PathParams>,) -> Result<Response, GetMessageError> {let message = email_db_client::messages::get_parsed::get_parsed_message_by_id(&ctx.db, &id)@@ -92,7 +93,7 @@ pub async fn handler(return Err(GetMessageError::MessageNotFound);};- let link_ids = owned_link_ids(&ctx, &user_context.user_id).await?;+ let link_ids = owned_link_ids(&ctx, &authorization.user_context.user_id).await?;if link_ids.contains(&message.link_id) {Ok(Json(message).into_response())} else {@@ -114,10 +115,10 @@ pub async fn handler((status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn batch_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Json(ids): Json<Vec<Uuid>>,) -> Result<Response, GetMessageError> {let messages =@@ -130,7 +131,7 @@ pub async fn batch_handler(return Err(GetMessageError::MessageNotFound);}- let link_ids = owned_link_ids(&ctx, &user_context.user_id).await?;+ let link_ids = owned_link_ids(&ctx, &authorization.user_context.user_id).await?;let accessible_messages = messages.into_iter().filter(|msg| link_ids.contains(&msg.link_id))diff --git a/services/email_service/src/api/email/messages/labels.rs b/services/email_service/src/api/email/messages/labels.rsindex 308e987718..c32d190bf1 100644--- a/services/email_service/src/api/email/messages/labels.rs+++ b/services/email_service/src/api/email/messages/labels.rs@@ -1,14 +1,14 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use crate::api::email::messages::BATCH_UPDATE_MESSAGE_LIMIT;use anyhow::Context;+use axum::Json;use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};use email::domain::events::{EmailEventOrigin, EmailMacroEvent, LabelRef};use email_service::pubsub::publish_email_event;+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use models_email::service;use sqlx::types::Uuid;use utoipa::ToSchema;@@ -43,10 +43,10 @@ pub struct UpdateLabelBatchResponse {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, body), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id))]+#[tracing::instrument(skip(ctx, authorization, body), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id))]pub async fn handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Json(body): Json<UpdateLabelBatchRequest>,) -> Result<Response, Response> {if body.message_ids.is_empty() || body.message_ids.len() > BATCH_UPDATE_MESSAGE_LIMIT {@@ -66,7 +66,7 @@ pub async fn handler(// delegated inboxes); a single label op targets messages in one inbox.let link = email_db_client::links::get::fetch_owned_link_for_message(&ctx.db,- &user_context.user_id,+ &authorization.user_context.user_id,body.message_ids[0],).await@@ -119,7 +119,7 @@ pub async fn handler(let db_messages = email_db_client::messages::get_simple_messages::get_simple_messages_batch(&ctx.db,&body.message_ids,- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,).await.map_err(|e| {@@ -186,7 +186,7 @@ pub async fn handler(email_db_client::messages::update::update_message_read_status_batch(&mut *tx,message_db_ids.clone(),- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,!is_adding,).await@@ -195,7 +195,7 @@ pub async fn handler(email_db_client::messages::update::update_message_starred_status_batch(&mut *tx,message_db_ids.clone(),- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,is_adding,).awaitdiff --git a/services/email_service/src/api/email/messages/mod.rs b/services/email_service/src/api/email/messages/mod.rsindex 3f4de22cd2..69dec74c19 100644--- a/services/email_service/src/api/email/messages/mod.rs+++ b/services/email_service/src/api/email/messages/mod.rs@@ -9,12 +9,16 @@ use crate::api::ApiContext;const BATCH_UPDATE_MESSAGE_LIMIT: usize = 10;-pub fn router(state: ApiContext) -> Router<ApiContext> {+pub fn router(_state: ApiContext) -> Router<ApiContext> {// Every route resolves its own inbox — send via EmailLinkExtractor, label// batch from the messages, and the reads union across the caller's inboxes —// so none carry the single-inbox X-Email-Link-Id middleware.Router::new()- .merge(send_router(state.email_service.clone()))+ .merge(send_router::<+ ApiContext,+ crate::api::context::EmailSvc,+ crate::api::context::AuthorizationService,+ >()).route("/labels", patch(labels::handler)).route("/batch", post(get::batch_handler)).route("/{id}", get(get::handler))diff --git a/services/email_service/src/api/email/settings/mod.rs b/services/email_service/src/api/email/settings/mod.rsindex 5b84935f16..85d233e34d 100644--- a/services/email_service/src/api/email/settings/mod.rs+++ b/services/email_service/src/api/email/settings/mod.rs@@ -9,7 +9,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {Router::new().route("/", patch(patch_settings_handler)).layer(axum::middleware::from_fn_with_state(- state.email_service,+ state.clone(),crate::api::middleware::link::attach_link_context,))}diff --git a/services/email_service/src/api/email/sync/disable.rs b/services/email_service/src/api/email/sync/disable.rsindex e1bd3f5651..4fc663dbb6 100644--- a/services/email_service/src/api/email/sync/disable.rs+++ b/services/email_service/src/api/email/sync/disable.rs@@ -1,10 +1,10 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::extract::State;use axum::http::StatusCode;use axum::response::{IntoResponse, Response};use axum::{Extension, Json};+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::email::service::link::Link;use models_email::email::service::pubsub::LinkManagerMessage;use strum_macros::AsRefStr;@@ -46,13 +46,13 @@ impl IntoResponse for DisableSyncError {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, link), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization, link), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn disable_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,link: Extension<Link>,) -> Result<Response, DisableSyncError> {- tracing::info!(user_id = %user_context.user_id, "Disable called");+ tracing::info!(user_id = %authorization.user_context.user_id, "Disable called");// Enqueue the delete operation to handle cleanup asynchronouslylet message = LinkManagerMessage::DeleteLink {diff --git a/services/email_service/src/api/email/sync/mod.rs b/services/email_service/src/api/email/sync/mod.rsindex c7a9c00c14..e28f3538e7 100644--- a/services/email_service/src/api/email/sync/mod.rs+++ b/services/email_service/src/api/email/sync/mod.rs@@ -16,7 +16,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {crate::api::middleware::gmail_token::attach_gmail_token,)).layer(axum::middleware::from_fn_with_state(- state.email_service,+ state.clone(),crate::api::middleware::link::attach_link_context,)),),diff --git a/services/email_service/src/api/email/threads/archived.rs b/services/email_service/src/api/email/threads/archived.rsindex 3ca304c01e..ab5fd36aca 100644--- a/services/email_service/src/api/email/threads/archived.rs+++ b/services/email_service/src/api/email/threads/archived.rs@@ -1,14 +1,14 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use anyhow::Context;+use axum::Json;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};use email::domain::events::{EmailEventOrigin, EmailMacroEvent, ThreadArchivedMetadata};use email_db_client::threads::update::update_inbox_visible_status;use email_service::pubsub::publish_email_event;+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::service::label::system_labels;use models_email::service::message::Message;use sqlx::types::Uuid;@@ -68,10 +68,10 @@ pub struct ArchiveThreadRequest {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context, body), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization, body), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn archived_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(thread_id): Path<Uuid>,Json(body): Json<ArchiveThreadRequest>,) -> Result<Response, ArchiveThreadError> {@@ -81,7 +81,7 @@ pub async fn archived_handler(// delegated inboxes.let link = email_db_client::links::get::fetch_owned_link_for_thread(&ctx.db,- &user_context.user_id,+ &authorization.user_context.user_id,thread_id,).await?diff --git a/services/email_service/src/api/email/threads/get.rs b/services/email_service/src/api/email/threads/get.rsindex e817930a48..172f7a08af 100644--- a/services/email_service/src/api/email/threads/get.rs+++ b/services/email_service/src/api/email/threads/get.rs@@ -1,11 +1,11 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use anyhow::Context;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json, extract};+use axum::{Json, extract};+use macro_authorization::MacroAuthorizationExtractor;use model::response::ErrorResponse;-use model::user::UserContext;use sqlx::types::Uuid;use std::collections::HashSet;use strum_macros::AsRefStr;@@ -89,22 +89,24 @@ const MESSAGE_MAX: i64 = 100;(status = 500, description = "Internal Server Error", body = ErrorResponse),),)]-#[tracing::instrument(skip(ctx, user_context), fields(user_id=user_context.user_id, fusionauth_user_id=user_context.fusion_user_id), err)]+#[tracing::instrument(skip(ctx, authorization), fields(user_id=authorization.user_context.user_id, fusionauth_user_id=authorization.user_context.fusion_user_id), err)]pub async fn get_thread_messages_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(PathParams { id }): Path<PathParams>,extract::Query(query_params): extract::Query<GetThreadMessagesParams>,) -> Result<Response, GetThreadError> {let p = process_get_thread_params(&query_params)?;- let link_ids: HashSet<Uuid> =- email_db_client::links::get::fetch_inboxes_for_macro_id(&ctx.db, &user_context.user_id)- .await- .context("Failed to fetch links")?- .into_iter()- .map(|link| link.id)- .collect();+ let link_ids: HashSet<Uuid> = email_db_client::links::get::fetch_inboxes_for_macro_id(+ &ctx.db,+ &authorization.user_context.user_id,+ )+ .await+ .context("Failed to fetch links")?+ .into_iter()+ .map(|link| link.id)+ .collect();let messages =email_db_client::messages::get_parsed::get_paginated_parsed_messages_by_thread_id(diff --git a/services/email_service/src/api/email/threads/mod.rs b/services/email_service/src/api/email/threads/mod.rsindex ab5586dea2..20177c7107 100644--- a/services/email_service/src/api/email/threads/mod.rs+++ b/services/email_service/src/api/email/threads/mod.rs@@ -14,7 +14,11 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {let routes = Router::new().nest("/previews",- email::inbound::axum::previews_router::router(state.email_service.clone()),+ email::inbound::axum::previews_router::router::<+ ApiContext,+ crate::api::context::EmailSvc,+ crate::api::context::AuthorizationService,+ >(),).route("/{id}/messages", get(get::get_thread_messages_handler)).route("/{id}/seen", post(seen::seen_handler))@@ -27,6 +31,7 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {ApiContext,crate::api::context::EmailSvc,email::outbound::GmailTokenProviderImpl,+ crate::api::context::AuthorizationService,>();let hex_thread_project_routes =diff --git a/services/email_service/src/api/email/threads/seen.rs b/services/email_service/src/api/email/threads/seen.rsindex e7f391a4af..62126461eb 100644--- a/services/email_service/src/api/email/threads/seen.rs+++ b/services/email_service/src/api/email/threads/seen.rs@@ -1,13 +1,13 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use anyhow::Context;+use axum::Json;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};-use axum::{Extension, Json};use email::domain::events::{EmailEventOrigin, EmailMacroEvent, ThreadReadMetadata};use email_service::pubsub::publish_email_event;+use macro_authorization::MacroAuthorizationExtractor;use model::response::{EmptyResponse, ErrorResponse};-use model::user::UserContext;use models_email::service::label::system_labels;use models_email::service::message::Message;use sqlx::types::Uuid;@@ -68,17 +68,17 @@ pub struct PathParams {(status = 500, body=ErrorResponse),))]-#[tracing::instrument(skip(ctx, user_context), err)]+#[tracing::instrument(skip(ctx, authorization), err)]pub async fn seen_handler(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,Path(PathParams { id: thread_id }): Path<PathParams>,) -> Result<Response, SeenThreadError> {// Resolve the inbox from the thread itself, scoped to the caller's own and// delegated inboxes.let link = email_db_client::links::get::fetch_owned_link_for_thread(&ctx.db,- &user_context.user_id,+ &authorization.user_context.user_id,thread_id,).await@@ -129,7 +129,7 @@ pub async fn seen_handler(email_db_client::messages::update::update_message_read_status_batch(&mut *tx,message_db_ids.clone(),- &user_context.fusion_user_id,+ &authorization.user_context.fusion_user_id,true,).awaitdiff --git a/services/email_service/src/api/internal/delete_user.rs b/services/email_service/src/api/internal/delete_user.rsindex f5e18e8df9..0fb90ad6e9 100644--- a/services/email_service/src/api/internal/delete_user.rs+++ b/services/email_service/src/api/internal/delete_user.rs@@ -1,14 +1,16 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::Json;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use models_email::email::service::pubsub::LinkManagerMessage;#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Path(fusionauth_user_id): Path<String>,) -> Result<Response, Response> {tracing::info!(user_id = fusionauth_user_id, "Delete user called");diff --git a/services/email_service/src/api/internal/get_message_by_id.rs b/services/email_service/src/api/internal/get_message_by_id.rsindex 72e2480c24..2afd2cfe59 100644--- a/services/email_service/src/api/internal/get_message_by_id.rs+++ b/services/email_service/src/api/internal/get_message_by_id.rs@@ -1,9 +1,10 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::{Path, State},http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use sqlx::types::Uuid;@@ -16,6 +17,7 @@ pub struct PathParams {#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Path(PathParams { id }): Path<PathParams>,) -> Result<Response, Response> {let message = email_db_client::messages::get_parsed::get_parsed_message_by_id(&ctx.db, &id)@@ -47,6 +49,7 @@ pub async fn handler(#[tracing::instrument(skip(ctx))]pub async fn get_message_by_id_batch_handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Json(ids): Json<Vec<Uuid>>,) -> Result<Response, Response> {let messages =diff --git a/services/email_service/src/api/internal/get_message_senders.rs b/services/email_service/src/api/internal/get_message_senders.rsindex 937c916efc..8ddc2e689c 100644--- a/services/email_service/src/api/internal/get_message_senders.rs+++ b/services/email_service/src/api/internal/get_message_senders.rs@@ -1,10 +1,11 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::State,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use models_email::service::message::{MessageSendersRequest, MessageSendersResponse};use strum_macros::AsRefStr;use thiserror::Error;@@ -41,6 +42,7 @@ impl IntoResponse for GetMessageSendersError {#[tracing::instrument(skip_all)]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Json(req_body): Json<MessageSendersRequest>,) -> Result<Response, GetMessageSendersError> {let link = email_db_client::links::get::fetch_link_by_macro_id(&ctx.db, &req_body.user_id)diff --git a/services/email_service/src/api/internal/get_messages_by_thread_id.rs b/services/email_service/src/api/internal/get_messages_by_thread_id.rsindex 3b4286d311..797cca8899 100644--- a/services/email_service/src/api/internal/get_messages_by_thread_id.rs+++ b/services/email_service/src/api/internal/get_messages_by_thread_id.rs@@ -1,9 +1,10 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::{self, State},http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use sqlx::types::Uuid;@@ -51,6 +52,7 @@ pub struct PathParams {#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,extract::Path(PathParams { id }): extract::Path<PathParams>,extract::Query(query_params): extract::Query<ListThreadsParams>,) -> Result<Response, Response> {diff --git a/services/email_service/src/api/internal/get_thread_histories.rs b/services/email_service/src/api/internal/get_thread_histories.rsindex 5a19a6603e..87ba48ddc5 100644--- a/services/email_service/src/api/internal/get_thread_histories.rs+++ b/services/email_service/src/api/internal/get_thread_histories.rs@@ -1,10 +1,11 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::State,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use models_email::service::message::{ThreadHistoryRequest, ThreadHistoryResponse};use strum_macros::AsRefStr;use thiserror::Error;@@ -41,6 +42,7 @@ impl IntoResponse for GetThreadHistoriesError {#[tracing::instrument(skip_all)]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Json(req_body): Json<ThreadHistoryRequest>,) -> Result<Response, GetThreadHistoriesError> {let link = email_db_client::links::get::fetch_link_by_macro_id(&ctx.db, &req_body.user_id)diff --git a/services/email_service/src/api/internal/get_thread_owner.rs b/services/email_service/src/api/internal/get_thread_owner.rsindex 53fefef43e..5ea2001a6b 100644--- a/services/email_service/src/api/internal/get_thread_owner.rs+++ b/services/email_service/src/api/internal/get_thread_owner.rs@@ -1,8 +1,9 @@-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use axum::Json;use axum::extract::{Path, State};use axum::http::StatusCode;use axum::response::{IntoResponse, Response};+use macro_authorization::InternalMacroAuthorizationExtractor;use macro_user_id::cowlike::CowLike;use macro_user_id::user_id::MacroUserIdStr;use model::response::ErrorResponse;@@ -12,6 +13,7 @@ use uuid::Uuid;#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Path(thread_id): Path<Uuid>,) -> Result<Response, Response> {let user_id = email_db_client::threads::get::get_macro_id_from_thread_id(&ctx.db, thread_id)diff --git a/services/email_service/src/api/internal/gmail/cancel.rs b/services/email_service/src/api/internal/gmail/cancel.rsindex 8ea4f83876..cee9fae178 100644--- a/services/email_service/src/api/internal/gmail/cancel.rs+++ b/services/email_service/src/api/internal/gmail/cancel.rs@@ -1,9 +1,10 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::State,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use models_email::email::service::backfill::BackfillJobStatus;use sqlx::types::Uuid;@@ -18,6 +19,7 @@ pub struct BackfillCancelParams {#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Json(req_body): Json<BackfillCancelParams>,) -> Result<Response, Response> {let job = email_db_client::backfill::job::get::get_backfill_job(&ctx.db, req_body.job_id)diff --git a/services/email_service/src/api/internal/gmail/create.rs b/services/email_service/src/api/internal/gmail/create.rsindex 47b5aecded..d6b5af00ae 100644--- a/services/email_service/src/api/internal/gmail/create.rs+++ b/services/email_service/src/api/internal/gmail/create.rs@@ -1,9 +1,10 @@-use crate::api::ApiContext;+use crate::api::{ApiContext, context::AuthorizationService};use axum::{extract::State,http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use models_email::email::service::backfill::{BackfillJobStatus, BackfillOperation, BackfillPubsubMessage, InitPayload, JobScopedPayload,@@ -32,6 +33,7 @@ pub struct LinkJobPair {#[tracing::instrument(skip(ctx))]pub async fn handler(State(ctx): State<ApiContext>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Json(req_body): Json<BackfillParams>,) -> Result<Response, Response> {let mut link_job_pairs: Vec<LinkJobPair> = Vec::new();diff --git a/services/email_service/src/api/internal/gmail/get.rs b/services/email_service/src/api/internal/gmail/get.rsindex 16f8c105cd..72d603e2e0 100644--- a/services/email_service/src/api/internal/gmail/get.rs+++ b/services/email_service/src/api/internal/gmail/get.rs@@ -1,8 +1,10 @@+use crate::api::context::AuthorizationService;use axum::extract::{Path, State};use axum::{http::StatusCode,response::{IntoResponse, Json, Response},};+use macro_authorization::InternalMacroAuthorizationExtractor;use model::response::ErrorResponse;use models_email::email::service::backfill::BackfillJob;use sqlx::PgPool;@@ -18,6 +20,7 @@ pub struct GetBackfillJobResponse {/// Get a backfill job.pub async fn handler(State(db): State<PgPool>,+ _: InternalMacroAuthorizationExtractor<AuthorizationService>,Path(job_id): Path<Uuid>,) -> Result<Response, Response> {let job = email_db_client::backfill::job::get::get_backfill_job(&db, job_id)diff --git a/services/email_service/src/api/middleware/gmail_token.rs b/services/email_service/src/api/middleware/gmail_token.rsindex badc158a88..09f215785b 100644--- a/services/email_service/src/api/middleware/gmail_token.rs+++ b/services/email_service/src/api/middleware/gmail_token.rs@@ -1,18 +1,18 @@use axum::extract::State;-use axum::{Extension, extract::Request, middleware::Next, response::Response};-use model::user::UserContext;+use axum::{extract::Request, middleware::Next, response::Response};+use macro_authorization::MacroAuthorizationExtractor;-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use email_service::util::gmail::auth::fetch_gmail_token_usercontext_response;pub(in crate::api) async fn attach_gmail_token(State(ctx): State<ApiContext>,- user_context: Extension<UserContext>,+ authorization: MacroAuthorizationExtractor<AuthorizationService>,mut req: Request,next: Next,) -> Result<Response, Response> {let gmail_token = fetch_gmail_token_usercontext_response(- &user_context,+ &authorization.user_context,&ctx.redis_client,&ctx.auth_service_client,)diff --git a/services/email_service/src/api/middleware/link.rs b/services/email_service/src/api/middleware/link.rsindex 28049aca78..c189d2c746 100644--- a/services/email_service/src/api/middleware/link.rs+++ b/services/email_service/src/api/middleware/link.rs@@ -5,12 +5,18 @@ use axum::{};use axum_extra::extract::Cached;use email::{domain::ports::EmailService, inbound::axum::axum_impls::EmailLinkExtractor};+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};-pub(in crate::api) async fn attach_link_context<U: EmailService>(- Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<U>>,+pub(in crate::api) async fn attach_link_context<U, Auth>(+ Cached(EmailLinkExtractor(link, _)): Cached<EmailLinkExtractor<U, Auth>>,mut req: Request,next: Next,-) -> Result<Response, Response> {+) -> Result<Response, Response>+where+ U: EmailService,+ Auth: MacroAuthorizationService,+ MacroAuthorizationState<Auth>: axum::extract::FromRef<crate::api::ApiContext>,+{let provider = match link.provider.as_str() {"GMAIL" => models_email::email::service::link::UserProvider::Gmail,other => {diff --git a/services/email_service/src/main.rs b/services/email_service/src/main.rsindex d92228153e..4b0c3fed8d 100644--- a/services/email_service/src/main.rs+++ b/services/email_service/src/main.rs@@ -1,5 +1,5 @@#![recursion_limit = "256"]-use crate::api::context::ApiContext;+use crate::api::context::{ApiContext, AuthorizationService};use anyhow::Context;use document_storage_service_client::DocumentStorageServiceClient;use email::{@@ -13,6 +13,7 @@ use email::{use entity_access::{domain::service::EntityAccessServiceImpl, outbound::PgAccessRepository};use frecency::{domain::services::FrecencyQueryServiceImpl, outbound::postgres::FrecencyPgStorage};use macro_auth::middleware::decode_jwt::JwtValidationArgs;+use macro_authorization::{InternalAuthConfig, MacroAuthJwtValidator, MacroAuthorizationState};use macro_entrypoint::MacroEntrypoint;use macro_env::Environment;use macro_event_broker::{KafkaEventPublisher, MacroEventBrokerService};@@ -124,6 +125,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: config.internal_api_key.to_string(),+ default_user_id: Some("macro|[email protected]".to_string()),+ },+ )));let sqs_client = Arc::new(sqs_client);let gmail_client = Arc::new(gmail_client);@@ -157,6 +165,7 @@ async fn main() -> anyhow::Result<()> {let email_thread_state = EmailThreadRouterState {service: email_service.service(),access_service: entity_access_service.clone(),+ authorization_state: authorization_state.clone(),};let auth_service_client = Arc::new(auth_service_client);let redis_conn = redis_client@@ -181,6 +190,7 @@ async fn main() -> anyhow::Result<()> {s3_client: Arc::new(s3_client),dss_client: Arc::new(dss_client),system_properties_service,+ authorization_state: authorization_state.clone(),jwt_args,email_service,entity_access_service,