Skip to content

armgit / macro

Public Imported from GitHub
0

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

feat(email): macro authorization (#4983)

Will Hutchinson7f040bece53d
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.rs
index 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.rs
index 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>
where
EmailRouterState<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>
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, .. }) =
- 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.rs
index 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.rs
index 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.rs
index 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>
where
S: 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.rs
index 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>
where
S: 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(&params)?;
diff --git a/crates/email/src/inbound/axum/list_labels_router.rs b/crates/email/src/inbound/axum/list_labels_router.rs
index 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>
where
S: 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.rs
index 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.rs
index 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.rs
index 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>
where
S: 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.rs
index 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>
where
S: 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 = state
diff --git a/crates/entity_access/src/inbound/axum_extractors/thread.rs b/crates/entity_access/src/inbound/axum_extractors/thread.rs
index 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 receipt
pub 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>
where
T: RequiredPermission,
Arc<Svc>: FromRef<S>,
Svc: EntityAccessService,
+ MacroAuthorizationState<Auth>: FromRef<S>,
+ Auth: MacroAuthorizationService,
S: Send + Sync + 'static,
{
type Rejection = ExtractorError;
@@ -45,10 +52,13 @@ where
async 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.rs
new file mode 100644
index 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.rs
index 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 @@ where
Edges: 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.rs
index 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.toml
index 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.rs
index 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::EntityAccessManagementServiceImpl
use 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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, &macro_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.rs
index 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.rs
index 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.rs
index 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,
)
.await
diff --git a/services/email_service/src/api/email/messages/mod.rs b/services/email_service/src/api/email/messages/mod.rs
index 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.rs
index 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.rs
index 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 asynchronously
let message = LinkManagerMessage::DeleteLink {
diff --git a/services/email_service/src/api/email/sync/mod.rs b/services/email_service/src/api/email/sync/mod.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,
)
.await
diff --git a/services/email_service/src/api/internal/delete_user.rs b/services/email_service/src/api/internal/delete_user.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,