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(soup): macro authorization (#4989)

Will Hutchinsonabb678d977e1
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 6ca7983643..873cc37cad 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -2640,11 +2640,18 @@
"crates/filter_ast",
"crates/graphql_common",
"crates/item_filters",
+ "crates/macro_auth",
+ "crates/macro_authorization",
+ "crates/macro_env",
+ "crates/macro_env_var",
"crates/macro_user_id",
"crates/model-entity",
+ "crates/model-error-response",
"crates/model_file_type",
+ "crates/model_user",
"crates/models_properties",
"crates/non_empty",
+ "crates/remote_env_var",
"crates/workspace-hack"
],
"graphql_email": [
@@ -2714,6 +2721,7 @@
"crates/item_filters",
"crates/last_online_tracker",
"crates/macro_auth",
+ "crates/macro_authorization",
"crates/macro_env",
"crates/macro_env_var",
"crates/macro_service_urls",
diff --git a/Cargo.lock b/Cargo.lock
index 109e98dbeb..b6ce7c788a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2858,7 +2858,6 @@ dependencies = [
"apollo-compiler",
"async-graphql",
"axum",
- "axum-extra",
"email",
"entity_access",
"graphql_common",
@@ -2866,12 +2865,14 @@ dependencies = [
"graphql_notification",
"graphql_properties",
"graphql_soup",
+ "macro_authorization",
"macro_user_id",
"model-entity",
"model_user",
"models_pagination",
"models_properties",
"models_soup",
+ "rootcause",
"serde",
"soup",
"tokio",
@@ -4720,6 +4721,7 @@ dependencies = [
"futures",
"item_filters",
"lol_html",
+ "macro_authorization",
"macro_db_migrator",
"macro_event_broker",
"macro_event_topics",
@@ -5967,11 +5969,15 @@ version = "0.1.0"
dependencies = [
"async-graphql",
"axum",
+ "axum-extra",
"filter_ast",
"item_filters",
+ "macro_authorization",
"macro_user_id",
"model-entity",
+ "model_user",
"models_properties",
+ "rootcause",
"tokio",
"uuid",
"workspace-hack",
@@ -6040,10 +6046,10 @@ dependencies = [
"filter_ast",
"graphql_common",
"item_filters",
+ "macro_authorization",
"macro_user_id",
"model-entity",
"model_file_type",
- "model_user",
"models_grouping",
"models_pagination",
"models_soup",
@@ -13329,6 +13335,7 @@ dependencies = [
"http-body-util",
"indexmap 2.14.0",
"item_filters",
+ "macro_authorization",
"macro_db_migrator",
"macro_user_id",
"mockall",
diff --git a/crates/complete_graph/Cargo.toml b/crates/complete_graph/Cargo.toml
index 8151dd5250..1fb4fda62f 100644
--- a/crates/complete_graph/Cargo.toml
+++ b/crates/complete_graph/Cargo.toml
@@ -8,7 +8,6 @@ version = "0.1.0"
anyhow = { workspace = true }
async-graphql = { workspace = true, features = ["dataloader"] }
axum = { workspace = true }
-axum-extra = { workspace = true }
email = { path = "../email", default-features = false, features = [
"axum",
"inbound",
@@ -22,8 +21,11 @@ graphql_email = { path = "../graphql_email" }
graphql_notification = { path = "../graphql_notification" }
graphql_properties = { path = "../graphql_properties" }
graphql_soup = { path = "../graphql_soup" }
+macro_authorization = { path = "../macro_authorization", features = [
+ "axum",
+ "outbound",
+] }
model-entity = { path = "../model-entity" }
-model_user = { path = "../model_user", features = ["axum"] }
soup = { path = "../soup", default-features = false, features = ["ports"] }
uuid = { workspace = true }
workspace-hack = { version = "0.1", path = "../workspace-hack" }
@@ -31,9 +33,11 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" }
[dev-dependencies]
apollo-compiler = { workspace = true }
macro_user_id = { path = "../macro_user_id" }
+model_user = { path = "../model_user", features = ["axum"] }
models_pagination = { path = "../models_pagination" }
models_properties = { path = "../models_properties" }
models_soup = { path = "../models_soup" }
+rootcause = { workspace = true }
serde = { workspace = true }
tokio = { workspace = true }
uuid = { workspace = true }
diff --git a/crates/complete_graph/src/schema.rs b/crates/complete_graph/src/schema.rs
index c0bf15f021..fd7d430498 100644
--- a/crates/complete_graph/src/schema.rs
+++ b/crates/complete_graph/src/schema.rs
@@ -5,13 +5,12 @@ use std::{marker::PhantomData, sync::Arc};
use async_graphql::{Context, EmptySubscription, Object, Schema};
use axum::extract::FromRef;
-use axum_extra::extract::Cached;
use email::{
domain::ports::{EmailService, NoOpEmailService},
inbound::axum::previews_router::EmailRouterState,
};
use entity_access::domain::ports::{EntityAccessService, NoOpEntityAccessService};
-use graphql_common::extract_part;
+use graphql_common::require_authorized_user;
use graphql_email::{NoOpSoupEmailContentEdgeReader, SoupEmailContentEdgeReader};
use graphql_notification::{NoOpSoupNotificationEdgeReader, SoupNotificationEdgeReader};
use graphql_properties::{
@@ -21,7 +20,10 @@ use graphql_properties::{
use graphql_soup::{
GroupedSoup, GroupedSoupInput, SoupInput, SoupPage, resolve_grouped_soup, resolve_soup,
};
-use model_user::axum_extractor::MacroUserExtractor;
+use macro_authorization::{
+ InternalAuthConfig, MacroAuthorizationService, MacroAuthorizationServiceImpl,
+ MacroAuthorizationState, NoopMacroAuthJwtValidator,
+};
use soup::domain::ports::{NoOpSoupService, SoupService};
use crate::SoupEdges;
@@ -29,15 +31,18 @@ use crate::SoupEdges;
/// GraphQL Soup schema type.
///
/// `S` is the soup service, `E` the email service, `EAS` the entity access
-/// service, `St` the embedding axum router state, `W` the property mutation
-/// writer, `NR` the notification edge reader, `PR` the property edge reader,
-/// and `ER` the email-content edge reader.
-pub type SoupSchema<S, E, EAS, St, W, NR, PR, ER> =
- Schema<SoupQueryRoot<S, E, EAS, St, NR, PR, ER>, PropertiesMutationRoot<W>, EmptySubscription>;
+/// service, `Auth` the authorization service, `St` the embedding axum router
+/// state, `W` the property mutation writer, `NR` the notification edge reader,
+/// `PR` the property edge reader, and `ER` the email-content edge reader.
+pub type SoupSchema<S, E, EAS, Auth, St, W, NR, PR, ER> = Schema<
+ SoupQueryRoot<S, E, EAS, Auth, St, NR, PR, ER>,
+ PropertiesMutationRoot<W>,
+ EmptySubscription,
+>;
/// GraphQL Soup schema type backed by a shared soup service.
-pub type SharedSoupSchema<S, E, EAS, St, W, NR, PR, ER> =
- SoupSchema<Arc<S>, E, EAS, St, W, NR, PR, ER>;
+pub type SharedSoupSchema<S, E, EAS, Auth, St, W, NR, PR, ER> =
+ SoupSchema<Arc<S>, E, EAS, Auth, St, W, NR, PR, ER>;
/// GraphQL Soup schema type backed by the no-op services, used only for
/// SDL export or introspection.
@@ -45,6 +50,7 @@ pub type SchemaOnlySoupSchema = SoupSchema<
NoOpSoupService,
NoOpEmailService,
NoOpEntityAccessService,
+ SchemaOnlyAuthorizationService,
SchemaOnlyState,
NoOpEntityPropertyWriter,
NoOpSoupNotificationEdgeReader,
@@ -52,6 +58,9 @@ pub type SchemaOnlySoupSchema = SoupSchema<
NoOpSoupEmailContentEdgeReader,
>;
+/// Authorization service used only to construct the GraphQL schema for SDL export.
+pub type SchemaOnlyAuthorizationService = MacroAuthorizationServiceImpl<NoopMacroAuthJwtValidator>;
+
/// Axum-style state used only to construct the GraphQL schema for SDL export.
#[derive(Clone, Copy, Debug, Default)]
pub struct SchemaOnlyState;
@@ -68,19 +77,33 @@ impl FromRef<SchemaOnlyState> for Arc<NoOpEntityAccessService> {
}
}
-/// Zero-sized marker tying the query objects to the email/entity-access/state
-/// generics without requiring values of those types.
-type ServicesMarker<E, EAS, St, NR, PR, ER> = PhantomData<fn() -> (E, EAS, St, NR, PR, ER)>;
+impl FromRef<SchemaOnlyState> for MacroAuthorizationState<SchemaOnlyAuthorizationService> {
+ fn from_ref(_state: &SchemaOnlyState) -> Self {
+ let service = MacroAuthorizationServiceImpl::new(
+ NoopMacroAuthJwtValidator,
+ InternalAuthConfig {
+ api_key: String::new(),
+ default_user_id: None,
+ },
+ );
+ MacroAuthorizationState::new(Arc::new(service))
+ }
+}
+
+/// Zero-sized marker tying the query objects to the adapter, authorization,
+/// state, and reader generics without requiring values of those types.
+type ServicesMarker<E, EAS, Auth, St, NR, PR, ER> =
+ PhantomData<fn() -> (E, EAS, Auth, St, NR, PR, ER)>;
/// Root GraphQL query object for Soup.
-pub struct SoupQueryRoot<S, E, EAS, St, NR, PR, ER> {
+pub struct SoupQueryRoot<S, E, EAS, Auth, St, NR, PR, ER> {
/// Soup domain service used by user-scoped query resolvers.
service: S,
/// Associates the root with its adapter and reader types.
- _marker: ServicesMarker<E, EAS, St, NR, PR, ER>,
+ _marker: ServicesMarker<E, EAS, Auth, St, NR, PR, ER>,
}
-impl<S, E, EAS, St, NR, PR, ER> SoupQueryRoot<S, E, EAS, St, NR, PR, ER> {
+impl<S, E, EAS, Auth, St, NR, PR, ER> SoupQueryRoot<S, E, EAS, Auth, St, NR, PR, ER> {
/// Create a root GraphQL query object.
pub fn new(service: S) -> Self {
Self {
@@ -93,11 +116,11 @@ impl<S, E, EAS, St, NR, PR, ER> SoupQueryRoot<S, E, EAS, St, NR, PR, ER> {
/// The authenticated user (viewer). All user-scoped data hangs off this
/// object so clients (and their normalized caches) observe data ownership
/// structurally rather than implicitly through the session.
-pub struct GraphqlUser<S, E, EAS, St, NR, PR, ER> {
+pub struct GraphqlUser<S, E, EAS, Auth, St, NR, PR, ER> {
/// Soup domain service used by this user's resolvers.
service: S,
/// Associates the user object with its adapter and reader types.
- _marker: ServicesMarker<E, EAS, St, NR, PR, ER>,
+ _marker: ServicesMarker<E, EAS, Auth, St, NR, PR, ER>,
}
/// Build a GraphQL schema for Soup suitable for SDL export or introspection.
@@ -106,16 +129,18 @@ pub fn build_schema() -> SchemaOnlySoupSchema {
}
/// Build a GraphQL schema for Soup backed by the provided service.
-pub fn build_schema_with_service<S, E, EAS, St, W, NR, PR, ER>(
+pub fn build_schema_with_service<S, E, EAS, Auth, St, W, NR, PR, ER>(
service: S,
-) -> SoupSchema<S, E, EAS, St, W, NR, PR, ER>
+) -> SoupSchema<S, E, EAS, Auth, St, W, NR, PR, ER>
where
S: SoupService + Clone,
E: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
St: Clone + Send + Sync + 'static,
EmailRouterState<E>: FromRef<St>,
Arc<EAS>: FromRef<St>,
+ MacroAuthorizationState<Auth>: FromRef<St>,
W: EntityPropertyWriter,
NR: SoupNotificationEdgeReader,
PR: EntityPropertyReader,
@@ -130,16 +155,18 @@ where
}
/// Build a GraphQL schema for Soup backed by an `Arc`-shared service.
-pub fn build_schema_from_arc<S, E, EAS, St, W, NR, PR, ER>(
+pub fn build_schema_from_arc<S, E, EAS, Auth, St, W, NR, PR, ER>(
service: Arc<S>,
-) -> SharedSoupSchema<S, E, EAS, St, W, NR, PR, ER>
+) -> SharedSoupSchema<S, E, EAS, Auth, St, W, NR, PR, ER>
where
S: SoupService,
E: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
St: Clone + Send + Sync + 'static,
EmailRouterState<E>: FromRef<St>,
Arc<EAS>: FromRef<St>,
+ MacroAuthorizationState<Auth>: FromRef<St>,
W: EntityPropertyWriter,
NR: SoupNotificationEdgeReader,
PR: EntityPropertyReader,
@@ -150,20 +177,22 @@ where
/// Root entry point for the complete GraphQL API.
#[Object]
-impl<S, E, EAS, St, NR, PR, ER> SoupQueryRoot<S, E, EAS, St, NR, PR, ER>
+impl<S, E, EAS, Auth, St, NR, PR, ER> SoupQueryRoot<S, E, EAS, Auth, St, NR, PR, ER>
where
S: SoupService + Clone,
E: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
St: Clone + Send + Sync + 'static,
EmailRouterState<E>: FromRef<St>,
Arc<EAS>: FromRef<St>,
+ MacroAuthorizationState<Auth>: FromRef<St>,
NR: SoupNotificationEdgeReader,
PR: EntityPropertyReader,
ER: SoupEmailContentEdgeReader,
{
/// The authenticated user.
- async fn user(&self) -> GraphqlUser<S, E, EAS, St, NR, PR, ER> {
+ async fn user(&self) -> GraphqlUser<S, E, EAS, Auth, St, NR, PR, ER> {
GraphqlUser {
service: self.service.clone(),
_marker: PhantomData,
@@ -173,22 +202,23 @@ where
/// The authenticated user and their user-scoped data.
#[Object(name = "GraphqlUser")]
-impl<S, E, EAS, St, NR, PR, ER> GraphqlUser<S, E, EAS, St, NR, PR, ER>
+impl<S, E, EAS, Auth, St, NR, PR, ER> GraphqlUser<S, E, EAS, Auth, St, NR, PR, ER>
where
S: SoupService,
E: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
St: Clone + Send + Sync + 'static,
EmailRouterState<E>: FromRef<St>,
Arc<EAS>: FromRef<St>,
+ MacroAuthorizationState<Auth>: FromRef<St>,
NR: SoupNotificationEdgeReader,
PR: EntityPropertyReader,
ER: SoupEmailContentEdgeReader,
{
/// Stable id of the authenticated user.
async fn id(&self, ctx: &Context<'_>) -> async_graphql::Result<async_graphql::ID> {
- let Cached(MacroUserExtractor { macro_user_id, .. }) =
- extract_part::<Cached<MacroUserExtractor>, St>(ctx).await?;
+ let macro_user_id = require_authorized_user::<Auth, St>(ctx).await?;
Ok(async_graphql::ID(macro_user_id.to_string()))
}
@@ -198,7 +228,7 @@ where
ctx: &Context<'_>,
input: GroupedSoupInput,
) -> async_graphql::Result<GroupedSoup<SoupEdges<NR, PR, ER>>> {
- resolve_grouped_soup::<S, St, SoupEdges<NR, PR, ER>>(&self.service, ctx, input).await
+ resolve_grouped_soup::<S, Auth, St, SoupEdges<NR, PR, ER>>(&self.service, ctx, input).await
}
/// Fetch a page of Soup items using the existing Soup filter AST format.
@@ -207,6 +237,6 @@ where
ctx: &Context<'_>,
input: SoupInput,
) -> async_graphql::Result<SoupPage<SoupEdges<NR, PR, ER>>> {
- resolve_soup::<S, E, EAS, St, SoupEdges<NR, PR, ER>>(&self.service, ctx, input).await
+ resolve_soup::<S, E, EAS, Auth, St, SoupEdges<NR, PR, ER>>(&self.service, ctx, input).await
}
}
diff --git a/crates/complete_graph/src/schema/test.rs b/crates/complete_graph/src/schema/test.rs
index 533fb22392..01bdac69b7 100644
--- a/crates/complete_graph/src/schema/test.rs
+++ b/crates/complete_graph/src/schema/test.rs
@@ -1,5 +1,6 @@
use std::sync::atomic::{AtomicUsize, Ordering};
+use axum::http::{Request as HttpRequest, header};
use email::domain::models::{
CreateDraftInput, CreatedDraft, EmailErr, EmailFilter, EnrichedEmailThreadPreview,
GetEmailsRequest, Link, LinkLabel, ParsedThread, Thread, UpdateThreadLabelsResult,
@@ -10,6 +11,10 @@ use entity_access::domain::models::{
EntityPermission, EntityType, RequiredPermission, UserTeamInfo, ViewAccessLevel,
};
use graphql_common::GraphqlSoupRequestParts;
+use macro_authorization::{
+ INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,
+ MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,
+};
use macro_user_id::{
lowercased::Lowercase,
user_id::{MacroUserId, MacroUserIdStr},
@@ -17,10 +22,15 @@ use macro_user_id::{
use model_user::UserContext;
use models_pagination::{PaginatedCursor, SimpleSortMethod};
use models_soup::{document::SoupDocument, item::SoupItem};
+use rootcause::Report;
use uuid::Uuid;
use super::*;
+const VALID_USER_ID: &str = "macro|[email protected]";
+const INTERNAL_USER_ID: &str = "macro|[email protected]";
+const VALID_INTERNAL_KEY: &str = "valid-internal-key";
+
#[derive(Clone, Default)]
struct CountingSoupService {
raw_calls: Arc<AtomicUsize>,
@@ -32,7 +42,7 @@ fn grouped_document(id: Uuid) -> SoupItem<soup::domain::models::SoupPropertiesFi
SoupItem::Document(SoupDocument {
id,
document_version_id: 1,
- owner_id: MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
+ owner_id: MacroUserIdStr::parse_from_str(VALID_USER_ID).unwrap(),
name: format!("Document {id}"),
file_type: None,
sha: None,
@@ -385,12 +395,59 @@ impl EntityAccessService for CountingEntityAccessService {
}
}
+#[derive(Clone, Default)]
+struct FakeAuthorizationService {
+ authorization_calls: Arc<AtomicUsize>,
+}
+
+impl MacroAuthorizationService for FakeAuthorizationService {
+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
+ self.authorization_calls.fetch_add(1, Ordering::SeqCst);
+
+ match jwt {
+ "valid" => Ok(user_context(VALID_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>> {
+ self.authorization_calls.fetch_add(1, Ordering::SeqCst);
+
+ if provided_key != VALID_INTERNAL_KEY {
+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
+ }
+
+ Ok(claims.user_id.map(|user_id| user_context(&user_id)))
+ }
+}
+
+fn user_context(user_id: &str) -> UserContext {
+ UserContext {
+ user_id: user_id.to_owned(),
+ fusion_user_id: "fusion-user-id".to_owned(),
+ permissions: None,
+ organization_id: None,
+ }
+}
+
#[derive(Clone)]
struct TestState {
+ authorization: MacroAuthorizationState<FakeAuthorizationService>,
email: EmailRouterState<CountingEmailService>,
entity_access: Arc<CountingEntityAccessService>,
}
+impl FromRef<TestState> for MacroAuthorizationState<FakeAuthorizationService> {
+ fn from_ref(state: &TestState) -> Self {
+ state.authorization.clone()
+ }
+}
+
impl FromRef<TestState> for EmailRouterState<CountingEmailService> {
fn from_ref(state: &TestState) -> Self {
state.email.clone()
@@ -408,6 +465,7 @@ struct TestHarness {
CountingSoupService,
CountingEmailService,
CountingEntityAccessService,
+ FakeAuthorizationService,
TestState,
NoOpEntityPropertyWriter,
NoOpSoupNotificationEdgeReader,
@@ -415,6 +473,7 @@ struct TestHarness {
NoOpSoupEmailContentEdgeReader,
>,
state: TestState,
+ authorization_calls: Arc<AtomicUsize>,
inbox_calls: Arc<AtomicUsize>,
team_calls: Arc<AtomicUsize>,
raw_soup_calls: Arc<AtomicUsize>,
@@ -425,7 +484,9 @@ struct TestHarness {
fn harness() -> TestHarness {
let email = CountingEmailService::default();
let entity_access = CountingEntityAccessService::default();
+ let authorization = FakeAuthorizationService::default();
let soup = CountingSoupService::default();
+ let authorization_calls = Arc::clone(&authorization.authorization_calls);
let inbox_calls = Arc::clone(&email.inbox_calls);
let team_calls = Arc::clone(&entity_access.team_calls);
let raw_soup_calls = Arc::clone(&soup.raw_calls);
@@ -434,9 +495,11 @@ fn harness() -> TestHarness {
TestHarness {
schema: build_schema_with_service(soup),
state: TestState {
+ authorization: MacroAuthorizationState::new(Arc::new(authorization)),
email: EmailRouterState::new(email),
entity_access: Arc::new(entity_access),
},
+ authorization_calls,
inbox_calls,
team_calls,
raw_soup_calls,
@@ -446,20 +509,38 @@ fn harness() -> TestHarness {
}
fn authenticated_parts() -> axum::http::request::Parts {
- let (mut parts, ()) = axum::http::Request::new(()).into_parts();
- parts.extensions.insert(UserContext {
- user_id: "macro|[email protected]".to_owned(),
- fusion_user_id: String::new(),
- permissions: None,
- organization_id: None,
- });
- parts
+ bearer_parts("valid")
+}
+
+fn bearer_parts(token: &str) -> axum::http::request::Parts {
+ let request = HttpRequest::builder()
+ .header(header::AUTHORIZATION, format!("Bearer {token}"))
+ .body(())
+ .unwrap();
+ request.into_parts().0
+}
+
+fn internal_parts(user_id: &str) -> axum::http::request::Parts {
+ let request = HttpRequest::builder()
+ .header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
+ .header(INTERNAL_MACRO_USER_ID_HEADER, user_id)
+ .body(())
+ .unwrap();
+ request.into_parts().0
}
impl TestHarness {
async fn execute(&self, query: &str) -> async_graphql::Response {
+ self.execute_with_parts(query, authenticated_parts()).await
+ }
+
+ async fn execute_with_parts(
+ &self,
+ query: &str,
+ parts: axum::http::request::Parts,
+ ) -> async_graphql::Response {
let request = async_graphql::Request::new(query)
- .data(GraphqlSoupRequestParts::new(authenticated_parts()))
+ .data(GraphqlSoupRequestParts::new(parts))
.data(self.state.clone());
self.schema.execute(request).await
}
@@ -476,6 +557,28 @@ async fn user_id_resolves_without_touching_services() {
response.data.to_string(),
r#"{user: {id: "macro|[email protected]"}}"#
);
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.raw_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.frecency_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.grouped_soup_calls.load(Ordering::SeqCst), 0);
+}
+
+#[tokio::test]
+async fn internal_authorization_uses_the_acting_user_claim() {
+ let harness = harness();
+
+ let response = harness
+ .execute_with_parts("{ user { id } }", internal_parts(INTERNAL_USER_ID))
+ .await;
+
+ assert!(response.errors.is_empty(), "{:?}", response.errors);
+ assert_eq!(
+ response.data.to_string(),
+ r#"{user: {id: "macro|[email protected]"}}"#
+ );
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 1);
assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
}
@@ -506,6 +609,9 @@ async fn soup_input_rejects_initial_and_continuation_together() {
assert!(!response.errors.is_empty());
assert_eq!(harness.raw_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.frecency_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
}
#[tokio::test]
@@ -518,15 +624,17 @@ async fn soup_requests_frecency_only_when_selected() {
assert_eq!(harness.raw_soup_calls.load(Ordering::SeqCst), 0);
assert_eq!(harness.frecency_soup_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
}
#[tokio::test]
-async fn group_soup_nests_items_in_bins_and_preserves_database_order() {
+async fn group_soup_nests_items_in_bins_and_reuses_cached_authorization() {
let harness = harness();
let response = harness
.execute(
- "{ user { groupSoup(input: {initial: {groupBy: {field: ENTITY_TYPE}}}) { bins { key totalCount nextCursor items { id entityType } } } } }",
+ "{ user { id groupSoup(input: {initial: {groupBy: {field: ENTITY_TYPE}}}) { bins { key totalCount nextCursor items { id entityType } } } } }",
)
.await;
@@ -535,6 +643,7 @@ async fn group_soup_nests_items_in_bins_and_preserves_database_order() {
let bin = &data["user"]["groupSoup"]["bins"][0];
assert_eq!(bin["key"], "document");
assert_eq!(bin["totalCount"], 3);
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 1);
let cursor = bin["nextCursor"].as_str().unwrap();
assert_eq!(bin["items"].as_array().unwrap().len(), 2);
@@ -544,6 +653,7 @@ async fn group_soup_nests_items_in_bins_and_preserves_database_order() {
let response = harness.execute(&continuation).await;
assert!(response.errors.is_empty(), "{:?}", response.errors);
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 2);
assert_eq!(harness.grouped_soup_calls.load(Ordering::SeqCst), 2);
assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
@@ -562,20 +672,56 @@ async fn crm_scoped_soup_resolves_team_membership_lazily() {
)
.await;
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 1);
assert_eq!(harness.team_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.raw_soup_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.frecency_soup_calls.load(Ordering::SeqCst), 0);
assert!(!response.errors.is_empty());
}
#[tokio::test]
async fn unauthenticated_request_fails_at_the_resolver() {
let harness = harness();
- let (parts, ()) = axum::http::Request::new(()).into_parts();
+ let parts = HttpRequest::new(()).into_parts().0;
- let request = async_graphql::Request::new("{ user { id } }")
- .data(GraphqlSoupRequestParts::new(parts))
- .data(harness.state.clone());
- let response = harness.schema.execute(request).await;
+ let response = harness.execute_with_parts("{ user { id } }", parts).await;
- assert!(!response.errors.is_empty());
+ assert_eq!(response.errors.len(), 1);
+ assert_eq!(response.errors[0].message, "authentication required");
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.raw_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.frecency_soup_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.grouped_soup_calls.load(Ordering::SeqCst), 0);
+}
+
+#[tokio::test]
+async fn invalid_credentials_return_the_safe_authorization_error() {
+ let harness = harness();
+
+ let response = harness
+ .execute_with_parts("{ user { id } }", bearer_parts("invalid"))
+ .await;
+
+ assert_eq!(response.errors.len(), 1);
+ assert_eq!(response.errors[0].message, "unauthorized");
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 1);
+ assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
+}
+
+#[tokio::test]
+async fn expired_credentials_return_the_safe_authorization_error() {
+ let harness = harness();
+
+ let response = harness
+ .execute_with_parts("{ user { id } }", bearer_parts("expired"))
+ .await;
+
+ assert_eq!(response.errors.len(), 1);
+ assert_eq!(response.errors[0].message, "jwt expired");
+ assert_eq!(harness.authorization_calls.load(Ordering::SeqCst), 1);
assert_eq!(harness.inbox_calls.load(Ordering::SeqCst), 0);
+ assert_eq!(harness.team_calls.load(Ordering::SeqCst), 0);
}
diff --git a/crates/crm/src/domain/auth.rs b/crates/crm/src/domain/auth.rs
index d95dc0fd06..66974f45f5 100644
--- a/crates/crm/src/domain/auth.rs
+++ b/crates/crm/src/domain/auth.rs
@@ -166,7 +166,7 @@ pub struct CrmTeamReceipt<T: RequiredPermission> {
impl<T: RequiredPermission> CrmTeamReceipt<T> {
/// Mint from a verified team-scoped access receipt (e.g. one
- /// produced by `MacroUserTeamExtractor`). Public because the receipt
+ /// produced by `MacroUserTeamExtractorV2`). Public because the receipt
/// is itself the capability and `team_id` is derived from its entity
/// id, so nothing can be forged. Errors if the receipt is not for a
/// `Team` or the id is malformed.
diff --git a/crates/email/Cargo.toml b/crates/email/Cargo.toml
index de1fa9aadd..b8c8773bc6 100644
--- a/crates/email/Cargo.toml
+++ b/crates/email/Cargo.toml
@@ -28,6 +28,7 @@ ai_tools = [
axum = [
"dep:axum",
"dep:axum-extra",
+ "dep:macro_authorization",
"dep:model-error-response",
"dep:model_user",
"dep:utoipa",
@@ -64,6 +65,7 @@ item_filters = { path = "../item_filters" }
lol_html = { workspace = true }
scraper = { workspace = true }
email_db_client = { path = "../email_db_client", optional = true }
+macro_authorization = { path = "../macro_authorization", default-features = false, features = ["axum"], optional = true }
macro_event_broker = { path = "../macro_event_broker", default-features = false }
macro_event_topics = { path = "../macro_event_topics" }
macro_user_id = { path = "../macro_user_id" }
diff --git a/crates/email/src/inbound/axum/axum_impls.rs b/crates/email/src/inbound/axum/axum_impls.rs
index aab9f7b7df..313c96388f 100644
--- a/crates/email/src/inbound/axum/axum_impls.rs
+++ b/crates/email/src/inbound/axum/axum_impls.rs
@@ -12,6 +12,10 @@ use axum::{
response::{IntoResponse, Response},
};
use axum_extra::extract::Cached;
+use macro_authorization::{
+ MacroAuthorizationExtractor, MacroAuthorizationRejection, MacroAuthorizationService,
+ MacroAuthorizationState,
+};
use macro_user_id::user_id::MacroUserIdStr;
use model_user::axum_extractor::{MacroUserExtractor, UserExtractorErr};
use std::sync::Arc;
@@ -96,23 +100,24 @@ pub enum EmailLinkErr {
#[error("No inbox specified; provide the X-Email-Link-Id header")]
NoInboxSelected,
#[error(transparent)]
+ Authorization(#[from] MacroAuthorizationRejection),
+ #[error(transparent)]
UserErr(#[from] UserExtractorErr),
}
impl IntoResponse for EmailLinkErr {
fn into_response(self) -> Response {
- if let EmailLinkErr::UserErr(u) = self {
- return u.into_response();
- }
- let status = match &self {
- EmailLinkErr::DbErr(_) | EmailLinkErr::UserErr(_) => StatusCode::INTERNAL_SERVER_ERROR,
- EmailLinkErr::NotFound => StatusCode::NOT_FOUND,
- EmailLinkErr::InvalidLinkIdHeader | EmailLinkErr::NoInboxSelected => {
- StatusCode::BAD_REQUEST
+ 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) => {
+ (StatusCode::BAD_REQUEST, error)
}
};
- (status, self.to_string()).into_response()
+ (status, error.to_string()).into_response()
}
}
@@ -208,6 +213,39 @@ where
}
}
+/// 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>,
+ 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 links = <EmailRouterState<U>>::from_ref(state)
+ .inner
+ .get_inboxes_for_macro_id(macro_user_id)
+ .await?;
+ Ok(Self(links, PhantomData))
+ }
+}
+
/// 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>);
diff --git a/crates/email/src/inbound/axum/axum_impls/test.rs b/crates/email/src/inbound/axum/axum_impls/test.rs
index 9f60a56fa9..82762a1548 100644
--- a/crates/email/src/inbound/axum/axum_impls/test.rs
+++ b/crates/email/src/inbound/axum/axum_impls/test.rs
@@ -1,7 +1,10 @@
-use super::{EmailLinkErr, resolve_target_link};
+use super::{EmailLinkErr, MultiEmailLinkExtractorV2, resolve_target_link};
use crate::domain::models::{Link, UserProvider};
+use axum::{body::to_bytes, http::StatusCode, response::IntoResponse};
use chrono::Utc;
+use macro_authorization::MacroAuthorizationRejection;
use macro_user_id::{email::EmailStr, user_id::MacroUserIdStr};
+use std::{borrow::Cow, marker::PhantomData};
use uuid::Uuid;
fn test_link(id: Uuid, owner: &str, email: &str, is_primary: bool) -> Link {
@@ -22,6 +25,30 @@ fn caller() -> MacroUserIdStr<'static> {
MacroUserIdStr::try_from_email("[email protected]").unwrap()
}
+#[tokio::test]
+async fn authorization_error_delegates_response() {
+ let rejection = MacroAuthorizationRejection {
+ status: StatusCode::IM_A_TEAPOT,
+ message: Cow::Borrowed("safe authorization error"),
+ };
+ let expected = rejection.clone().into_response();
+ let actual = EmailLinkErr::Authorization(rejection).into_response();
+
+ assert_eq!(actual.status(), expected.status());
+ let actual_body = to_bytes(actual.into_body(), usize::MAX).await.unwrap();
+ let expected_body = to_bytes(expected.into_body(), usize::MAX).await.unwrap();
+ assert_eq!(actual_body, expected_body);
+ assert_eq!(actual_body, r#"{"message":"safe authorization error"}"#);
+}
+
+#[test]
+fn multi_email_link_extractor_v2_is_cloneable_without_generic_clone_bounds() {
+ struct NotClone;
+
+ let extractor = MultiEmailLinkExtractorV2::<NotClone, NotClone>(Vec::new(), PhantomData);
+ let _clone = extractor.clone();
+}
+
#[test]
fn header_selects_owned_link() {
let id1 = Uuid::from_u128(1);
diff --git a/crates/entity_access/src/inbound/axum_extractors/mod.rs b/crates/entity_access/src/inbound/axum_extractors/mod.rs
index e0adc08878..3c90c89253 100644
--- a/crates/entity_access/src/inbound/axum_extractors/mod.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/mod.rs
@@ -33,10 +33,7 @@ pub use pin::PinAccessLevelExtractor;
pub use project::{
ProjectAccessLevelExtractor, ProjectBodyAccessLevelExtractor, ProjectBodyAccessLevelExtractorV2,
};
-pub use team::{
- MacroUserTeamExtractor, MacroUserTeamExtractorV2, OptionalMacroUserTeamExtractor,
- OptionalMacroUserTeamExtractorV2,
-};
+pub use team::{MacroUserTeamExtractorV2, OptionalMacroUserTeamExtractorV2};
pub use thread::ThreadAccessLevelExtractor;
use std::borrow::Cow;
@@ -114,7 +111,7 @@ impl From<AccessError> for ExtractorError {
}
impl From<MacroAuthorizationRejection> for ExtractorError {
- fn from((status, Json(ErrorResponse { message })): MacroAuthorizationRejection) -> Self {
+ fn from(MacroAuthorizationRejection { status, message }: MacroAuthorizationRejection) -> Self {
Self::Authorization { status, message }
}
}
diff --git a/crates/entity_access/src/inbound/axum_extractors/team.rs b/crates/entity_access/src/inbound/axum_extractors/team.rs
index 49a2ca391d..8dc5482a0b 100644
--- a/crates/entity_access/src/inbound/axum_extractors/team.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/team.rs
@@ -25,7 +25,6 @@ use macro_authorization::{
MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState,
};
use macro_user_id::user_id::MacroUserIdStr;
-use model_user::axum_extractor::MacroUserExtractor;
enum TeamAccessOutcome<T: RequiredPermission> {
Qualifying(EntityAccessReceipt<T>),
@@ -86,61 +85,6 @@ where
}))
}
-/// Resolves the authenticated user's **OPTIONAL** team membership and exposes the receipt
-/// when the user satisfies the required permission `T`.
-///
-/// `entity_access_receipt` is:
-/// - `Some(receipt)` if the user belongs to a team and their role satisfies `T`
-/// - `None` if the user belongs to a team but their role does not satisfy `T`
-/// - `None` if the user belongs to no team
-///
-/// Returns `ExtractorError::Unauthorized` if there is no authenticated user.
-#[derive(Debug)]
-pub struct OptionalMacroUserTeamExtractor<T: RequiredPermission, Svc> {
- /// The entity access receipt, if the user has a qualifying team membership.
- pub entity_access_receipt: Option<EntityAccessReceipt<T>>,
- _marker: PhantomData<(T, Svc)>,
-}
-
-impl<T: RequiredPermission, Svc> Clone for OptionalMacroUserTeamExtractor<T, Svc>
-where
- EntityAccessReceipt<T>: Clone,
-{
- fn clone(&self) -> Self {
- Self {
- entity_access_receipt: self.entity_access_receipt.clone(),
- _marker: PhantomData,
- }
- }
-}
-
-impl<T, S, Svc> FromRequestParts<S> for OptionalMacroUserTeamExtractor<T, Svc>
-where
- T: RequiredPermission,
- Arc<Svc>: FromRef<S>,
- Svc: EntityAccessService,
- S: Send + Sync + 'static,
-{
- type Rejection = ExtractorError;
-
- #[tracing::instrument(err, skip(state, parts))]
- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
- let service = <Arc<Svc>>::from_ref(state);
-
- let MacroUserExtractor { macro_user_id, .. } = parts
- .extract()
- .await
- .map_err(|_| ExtractorError::Unauthorized)?;
-
- let outcome = team_access_outcome::<T, Svc>(service.as_ref(), macro_user_id).await?;
-
- Ok(Self {
- entity_access_receipt: outcome.into_optional_receipt(),
- _marker: PhantomData,
- })
- }
-}
-
/// Authorizes a user and resolves their optional team membership.
///
/// The extractor uses the required [`MacroAuthorizationExtractor`], so missing,
@@ -234,42 +178,3 @@ where
})
}
}
-
-/// Resolves the authenticated user's team membership and exposes the receipt
-/// when the user satisfies the required permission `T`.
-/// Returns `ExtractorError::Unauthorized` if there is no authenticated user or no team.
-#[derive(Debug)]
-pub struct MacroUserTeamExtractor<T: RequiredPermission, Svc> {
- /// The entity access receipt.
- pub entity_access_receipt: EntityAccessReceipt<T>,
- _marker: PhantomData<(T, Svc)>,
-}
-
-impl<T, S, Svc> FromRequestParts<S> for MacroUserTeamExtractor<T, Svc>
-where
- T: RequiredPermission,
- Arc<Svc>: FromRef<S>,
- Svc: EntityAccessService,
- S: Send + Sync + 'static,
-{
- type Rejection = ExtractorError;
-
- #[tracing::instrument(err, skip(state, parts))]
- async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
- let service = <Arc<Svc>>::from_ref(state);
-
- let MacroUserExtractor { macro_user_id, .. } = parts
- .extract()
- .await
- .map_err(|_| ExtractorError::Unauthorized)?;
-
- let entity_access_receipt = team_access_outcome::<T, Svc>(service.as_ref(), macro_user_id)
- .await?
- .into_required_receipt()?;
-
- Ok(Self {
- entity_access_receipt,
- _marker: PhantomData,
- })
- }
-}
diff --git a/crates/entity_access/src/inbound/axum_extractors/team/test.rs b/crates/entity_access/src/inbound/axum_extractors/team/test.rs
index 00cac03bfc..0b54349577 100644
--- a/crates/entity_access/src/inbound/axum_extractors/team/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/team/test.rs
@@ -39,7 +39,6 @@ type V2Extractor = OptionalMacroUserTeamExtractorV2<
>;
type RequiredV2Extractor =
MacroUserTeamExtractorV2<AdminTeamRole, FakeEntityAccessService, FakeAuthorizationService>;
-type V1RequiredExtractor = MacroUserTeamExtractor<AdminTeamRole, FakeEntityAccessService>;
#[derive(Clone, Debug, Default)]
struct FakeEntityAccessService {
@@ -257,15 +256,6 @@ async fn extract_required_v2(
RequiredV2Extractor::from_request_parts(&mut parts, state).await
}
-async fn extract_v1_required(
- mut request: Request<Body>,
- state: &TestState,
-) -> Result<V1RequiredExtractor, ExtractorError> {
- request.extensions_mut().insert(user_context(USER_ID));
- let (mut parts, _) = request.into_parts();
- V1RequiredExtractor::from_request_parts(&mut parts, state).await
-}
-
async fn response_parts(response: Response) -> (StatusCode, String) {
let status = response.status();
let body = to_bytes(response.into_body(), usize::MAX)
@@ -551,33 +541,6 @@ async fn identity_less_internal_request_is_unauthorized() {
assert_eq!(body, r#"{"message":"unauthorized"}"#);
}
-#[tokio::test]
-async fn v1_required_extractor_preserves_team_failure_messages() {
- let no_team_state = state(
- FakeEntityAccessService::default(),
- FakeAuthorizationService::default(),
- );
- let no_team_error = extract_v1_required(request(), &no_team_state)
- .await
- .expect_err("required V1 extraction should reject absent membership");
- assert!(matches!(
- no_team_error,
- ExtractorError::UnauthorizedWithMessage("not in a team")
- ));
-
- let insufficient_role_state = state(
- FakeEntityAccessService::default().with_membership(USER_ID, TeamRole::Member),
- FakeAuthorizationService::default(),
- );
- let insufficient_role_error = extract_v1_required(request(), &insufficient_role_state)
- .await
- .expect_err("required V1 extraction should reject an insufficient role");
- assert!(matches!(
- insufficient_role_error,
- ExtractorError::UnauthorizedWithMessage("you do not have a high enough role")
- ));
-}
-
#[test]
fn v2_clone_does_not_require_service_types_to_be_clone() {
struct NotClone;
diff --git a/crates/entity_access/src/inbound/axum_extractors/test.rs b/crates/entity_access/src/inbound/axum_extractors/test.rs
index 158ecc640a..301f5b306d 100644
--- a/crates/entity_access/src/inbound/axum_extractors/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/test.rs
@@ -1,13 +1,11 @@
use std::borrow::Cow;
use axum::{
- Json,
body::to_bytes,
http::StatusCode,
response::{IntoResponse, Response},
};
use macro_authorization::MacroAuthorizationRejection;
-use model_error_response::ErrorResponse;
use super::ExtractorError;
@@ -24,12 +22,10 @@ async fn response_parts(response: Response) -> (StatusCode, String) {
#[tokio::test]
async fn authorization_rejection_preserves_status_and_owned_message() {
- let rejection: MacroAuthorizationRejection = (
- StatusCode::FORBIDDEN,
- Json(ErrorResponse {
- message: Cow::Owned("access forbidden".to_string()),
- }),
- );
+ let rejection = MacroAuthorizationRejection {
+ status: StatusCode::FORBIDDEN,
+ message: Cow::Owned("access forbidden".to_string()),
+ };
let response = ExtractorError::from(rejection).into_response();
let (status, body) = response_parts(response).await;
@@ -40,12 +36,10 @@ async fn authorization_rejection_preserves_status_and_owned_message() {
#[tokio::test]
async fn authorization_rejection_preserves_jwt_expired_response() {
- let rejection: MacroAuthorizationRejection = (
- StatusCode::UNAUTHORIZED,
- Json(ErrorResponse {
- message: Cow::Borrowed("jwt expired"),
- }),
- );
+ let rejection = MacroAuthorizationRejection {
+ status: StatusCode::UNAUTHORIZED,
+ message: Cow::Borrowed("jwt expired"),
+ };
let response = ExtractorError::from(rejection).into_response();
let (status, body) = response_parts(response).await;
diff --git a/crates/graphql_common/Cargo.toml b/crates/graphql_common/Cargo.toml
index efa428440d..c140e2f0e3 100644
--- a/crates/graphql_common/Cargo.toml
+++ b/crates/graphql_common/Cargo.toml
@@ -7,11 +7,17 @@ publish = false
[dependencies]
async-graphql = { workspace = true }
axum = { workspace = true }
+axum-extra = { workspace = true }
filter_ast = { path = "../filter_ast" }
item_filters = { path = "../item_filters" }
+macro_authorization = { path = "../macro_authorization", default-features = false, features = ["axum"] }
macro_user_id = { path = "../macro_user_id" }
model-entity = { path = "../model-entity" }
models_properties = { path = "../models_properties" }
tokio = { workspace = true }
uuid = { workspace = true }
workspace-hack = { version = "0.1", path = "../workspace-hack" }
+
+[dev-dependencies]
+model_user = { path = "../model_user" }
+rootcause = { workspace = true }
diff --git a/crates/graphql_common/src/authorization.rs b/crates/graphql_common/src/authorization.rs
new file mode 100644
index 0000000000..4812f9d478
--- /dev/null
+++ b/crates/graphql_common/src/authorization.rs
@@ -0,0 +1,30 @@
+#[cfg(test)]
+mod test;
+
+use async_graphql::Context;
+use axum::extract::FromRef;
+use axum_extra::extract::Cached;
+use macro_authorization::{
+ MacroAuthorizationService, MacroAuthorizationState, OptionalMacroAuthorizationExtractor,
+};
+use macro_user_id::user_id::MacroUserIdStr;
+
+use crate::extract_part;
+
+/// Extract the authorized caller (reusing the `Cached` entry primed by the
+/// mounting HTTP handler) and require an authenticated user.
+pub async fn require_authorized_user<Auth, St>(
+ ctx: &Context<'_>,
+) -> async_graphql::Result<MacroUserIdStr<'static>>
+where
+ Auth: MacroAuthorizationService,
+ MacroAuthorizationState<Auth>: FromRef<St>,
+ St: Clone + Send + Sync + 'static,
+{
+ let Cached(authorization) =
+ extract_part::<Cached<OptionalMacroAuthorizationExtractor<Auth>>, St>(ctx).await?;
+
+ authorization
+ .macro_user_id
+ .ok_or_else(|| async_graphql::Error::new("authentication required"))
+}
diff --git a/crates/graphql_common/src/authorization/test.rs b/crates/graphql_common/src/authorization/test.rs
new file mode 100644
index 0000000000..c27815ad16
--- /dev/null
+++ b/crates/graphql_common/src/authorization/test.rs
@@ -0,0 +1,161 @@
+use std::sync::{
+ Arc,
+ atomic::{AtomicUsize, Ordering},
+};
+
+use async_graphql::{Context, EmptyMutation, EmptySubscription, Object, Schema};
+use axum::{
+ extract::FromRef,
+ http::{Request as HttpRequest, header},
+};
+use macro_authorization::{
+ InternalIdentityClaims, MacroAuthorizationError, MacroAuthorizationService,
+ MacroAuthorizationState,
+};
+use model_user::UserContext;
+use rootcause::Report;
+
+use super::*;
+use crate::GraphqlSoupRequestParts;
+
+const VALID_USER_ID: &str = "macro|[email protected]";
+
+#[derive(Clone, Default)]
+struct FakeAuthorizationService {
+ authorization_calls: Arc<AtomicUsize>,
+}
+
+impl FakeAuthorizationService {
+ fn authorization_calls(&self) -> usize {
+ self.authorization_calls.load(Ordering::SeqCst)
+ }
+}
+
+impl MacroAuthorizationService for FakeAuthorizationService {
+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
+ self.authorization_calls.fetch_add(1, Ordering::SeqCst);
+
+ if jwt != "valid" {
+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
+ }
+
+ Ok(UserContext {
+ user_id: VALID_USER_ID.to_string(),
+ fusion_user_id: "fusion-user-id".to_string(),
+ permissions: None,
+ organization_id: None,
+ })
+ }
+
+ async fn authorize_internal(
+ &self,
+ _provided_key: &str,
+ _claims: InternalIdentityClaims,
+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {
+ Err(Report::new(MacroAuthorizationError::InvalidCredentials))
+ }
+}
+
+#[derive(Clone)]
+struct TestState {
+ authorization: MacroAuthorizationState<FakeAuthorizationService>,
+}
+
+impl FromRef<TestState> for MacroAuthorizationState<FakeAuthorizationService> {
+ fn from_ref(state: &TestState) -> Self {
+ state.authorization.clone()
+ }
+}
+
+struct TestQuery;
+
+#[Object]
+impl TestQuery {
+ async fn user_id(&self, ctx: &Context<'_>) -> async_graphql::Result<String> {
+ Ok(
+ require_authorized_user::<FakeAuthorizationService, TestState>(ctx)
+ .await?
+ .to_string(),
+ )
+ }
+
+ async fn repeated_user_ids(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<String>> {
+ let first = require_authorized_user::<FakeAuthorizationService, TestState>(ctx).await?;
+ let second = require_authorized_user::<FakeAuthorizationService, TestState>(ctx).await?;
+
+ Ok(vec![first.to_string(), second.to_string()])
+ }
+}
+
+async fn execute(
+ service: &FakeAuthorizationService,
+ bearer_token: Option<&str>,
+ query: &str,
+) -> async_graphql::Response {
+ let request = match bearer_token {
+ Some(token) => HttpRequest::builder()
+ .header(header::AUTHORIZATION, format!("Bearer {token}"))
+ .body(())
+ .unwrap(),
+ None => HttpRequest::new(()),
+ };
+ let (parts, ()) = request.into_parts();
+ let state = TestState {
+ authorization: MacroAuthorizationState::new(Arc::new(service.clone())),
+ };
+ let schema = Schema::build(TestQuery, EmptyMutation, EmptySubscription).finish();
+ let request = async_graphql::Request::new(query)
+ .data(GraphqlSoupRequestParts::new(parts))
+ .data(state);
+
+ schema.execute(request).await
+}
+
+#[tokio::test]
+async fn valid_bearer_returns_macro_user_id() {
+ let service = FakeAuthorizationService::default();
+
+ let response = execute(&service, Some("valid"), "{ userId }").await;
+
+ assert!(response.errors.is_empty(), "{:?}", response.errors);
+ assert_eq!(
+ response.data.to_string(),
+ r#"{userId: "macro|[email protected]"}"#
+ );
+}
+
+#[tokio::test]
+async fn missing_credentials_require_authentication() {
+ let service = FakeAuthorizationService::default();
+
+ let response = execute(&service, None, "{ userId }").await;
+
+ assert_eq!(response.errors.len(), 1);
+ assert_eq!(response.errors[0].message, "authentication required");
+ assert_eq!(service.authorization_calls(), 0);
+}
+
+#[tokio::test]
+async fn invalid_credentials_preserve_safe_authorization_message() {
+ let service = FakeAuthorizationService::default();
+
+ let response = execute(&service, Some("invalid"), "{ userId }").await;
+
+ assert_eq!(response.errors.len(), 1);
+ assert_eq!(response.errors[0].message, "unauthorized");
+ assert_eq!(service.authorization_calls(), 1);
+}
+
+#[tokio::test]
+async fn repeated_helper_calls_share_cached_authorization() {
+ let service = FakeAuthorizationService::default();
+
+ let response = execute(&service, Some("valid"), "{ repeatedUserIds }").await;
+
+ assert!(response.errors.is_empty(), "{:?}", response.errors);
+ assert_eq!(
+ response.data.to_string(),
+ r#"{repeatedUserIds: ["macro|[email protected]", "macro|[email protected]"]}"#
+ );
+ assert_eq!(service.authorization_calls(), 1);
+}
diff --git a/crates/graphql_common/src/lib.rs b/crates/graphql_common/src/lib.rs
index fad4c6beaf..eec3c05e39 100644
--- a/crates/graphql_common/src/lib.rs
+++ b/crates/graphql_common/src/lib.rs
@@ -7,6 +7,8 @@
// Re-exported for use by the `filter_expr_input!` macro expansion.
pub use filter_ast;
+/// GraphQL authorization helpers.
+mod authorization;
/// Shared GraphQL entity-type mappings.
mod entity_type;
/// Axum request-parts extraction helpers for GraphQL resolvers.
@@ -18,6 +20,7 @@ mod property_filter;
/// Request-scoped context used by GraphQL resolvers.
mod request_context;
+pub use authorization::require_authorized_user;
pub use entity_type::GraphqlSoupEntityType;
pub use extract::extract_part;
pub use filter_input::{IntoFilterExpr, optional_tree, parse_id, parse_macro_user_id, parse_uuid};
diff --git a/crates/graphql_soup/Cargo.toml b/crates/graphql_soup/Cargo.toml
index 0f3a3e5599..b8e6e82229 100644
--- a/crates/graphql_soup/Cargo.toml
+++ b/crates/graphql_soup/Cargo.toml
@@ -21,10 +21,10 @@ entity_access = { path = "../entity_access", default-features = false, features
filter_ast = { path = "../filter_ast" }
graphql_common = { path = "../graphql_common" }
item_filters = { path = "../item_filters" }
+macro_authorization = { path = "../macro_authorization", default-features = false, features = ["axum"] }
macro_user_id = { path = "../macro_user_id" }
model-entity = { path = "../model-entity" }
model_file_type = { path = "../model_file_type" }
-model_user = { path = "../model_user", features = ["axum"] }
models_grouping = { path = "../models_grouping" }
models_pagination = { path = "../models_pagination" }
models_soup = { path = "../models_soup" }
diff --git a/crates/graphql_soup/src/resolvers.rs b/crates/graphql_soup/src/resolvers.rs
index 7af80a416b..6e6b0636f6 100644
--- a/crates/graphql_soup/src/resolvers.rs
+++ b/crates/graphql_soup/src/resolvers.rs
@@ -5,14 +5,14 @@ use axum::extract::FromRef;
use axum_extra::extract::Cached;
use email::{
domain::ports::EmailService,
- inbound::axum::{axum_impls::MultiEmailLinkExtractor, previews_router::EmailRouterState},
+ inbound::axum::{axum_impls::MultiEmailLinkExtractorV2, previews_router::EmailRouterState},
};
use entity_access::{
domain::{models::MemberTeamRole, ports::EntityAccessService},
- inbound::axum_extractors::OptionalMacroUserTeamExtractor,
+ inbound::axum_extractors::OptionalMacroUserTeamExtractorV2,
};
-use graphql_common::extract_part;
-use model_user::axum_extractor::MacroUserExtractor;
+use graphql_common::{extract_part, require_authorized_user};
+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};
use models_pagination::TypeEraseCursor;
use soup::domain::{models::grouping::NestedSoupGroups, ports::SoupService};
@@ -22,18 +22,19 @@ use crate::{
};
/// Resolve Soup items nested into grouping bins for the authenticated user.
-pub async fn resolve_grouped_soup<S, St, Edges>(
+pub async fn resolve_grouped_soup<S, Auth, St, Edges>(
service: &S,
ctx: &Context<'_>,
input: GroupedSoupInput,
) -> async_graphql::Result<GroupedSoup<Edges>>
where
S: SoupService,
+ Auth: MacroAuthorizationService,
+ MacroAuthorizationState<Auth>: FromRef<St>,
St: Clone + Send + Sync + 'static,
Edges: SoupEntityEdges,
{
- let Cached(MacroUserExtractor { macro_user_id, .. }) =
- extract_part::<Cached<MacroUserExtractor>, St>(ctx).await?;
+ let macro_user_id = require_authorized_user::<Auth, St>(ctx).await?;
let request = input.into_request(macro_user_id)?;
let sort_method = *request.cursor.sort_method();
let filters = request.cursor.filter().clone();
@@ -47,7 +48,7 @@ where
/// Resolve a page of Soup items for the authenticated user: runs the lazy
/// axum extractors against the request context, converts the GraphQL input
/// into a Soup request, and executes it against the Soup service.
-pub async fn resolve_soup<S, E, EAS, St, Edges>(
+pub async fn resolve_soup<S, E, EAS, Auth, St, Edges>(
service: &S,
ctx: &Context<'_>,
input: SoupInput,
@@ -56,15 +57,16 @@ where
S: SoupService,
E: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
St: Clone + Send + Sync + 'static,
EmailRouterState<E>: FromRef<St>,
Arc<EAS>: FromRef<St>,
+ MacroAuthorizationState<Auth>: FromRef<St>,
Edges: SoupEntityEdges,
{
- let Cached(MacroUserExtractor { macro_user_id, .. }) =
- extract_part::<Cached<MacroUserExtractor>, St>(ctx).await?;
- let Cached(MultiEmailLinkExtractor(links, _)) =
- extract_part::<Cached<MultiEmailLinkExtractor<E>>, St>(ctx).await?;
+ 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 link_ids = links.into_iter().map(|link| link.id).collect();
let request = input.into_request(macro_user_id, link_ids)?;
@@ -74,16 +76,17 @@ where
// companies) is enforced by the soup domain and CRM service from
// the receipt.
let effective_filter = request.cursor.filter();
- let team_receipt = if effective_filter.requests_crm_scope()
- || effective_filter.requests_crm_admin()
- {
- let Cached(team) =
- extract_part::<Cached<OptionalMacroUserTeamExtractor<MemberTeamRole, EAS>>, St>(ctx)
- .await?;
- team.entity_access_receipt
- } else {
- None
- };
+ let team_receipt =
+ if effective_filter.requests_crm_scope() || effective_filter.requests_crm_admin() {
+ let Cached(team) = extract_part::<
+ Cached<OptionalMacroUserTeamExtractorV2<MemberTeamRole, EAS, Auth>>,
+ St,
+ >(ctx)
+ .await?;
+ team.entity_access_receipt
+ } else {
+ None
+ };
let include_frecency = ctx
.look_ahead()
diff --git a/crates/macro_authorization/src/inbound/axum.rs b/crates/macro_authorization/src/inbound/axum.rs
index 82ac9c765e..855d9cffec 100644
--- a/crates/macro_authorization/src/inbound/axum.rs
+++ b/crates/macro_authorization/src/inbound/axum.rs
@@ -1,12 +1,13 @@
#[cfg(test)]
mod test;
-use std::{marker::PhantomData, sync::Arc};
+use std::{borrow::Cow, fmt, marker::PhantomData, sync::Arc};
use ::axum::{
Json,
extract::{FromRef, FromRequestParts, Query},
http::{HeaderMap, StatusCode, header, request::Parts},
+ response::{IntoResponse, Response},
};
use macro_auth::headers::AccessTokenExtractor;
#[cfg(feature = "local_auth")]
@@ -36,7 +37,28 @@ pub const LEGACY_DSS_INTERNAL_API_KEY_HEADER: &str = "x-document-storage-service
pub const LEGACY_DSS_INTERNAL_MACRO_USER_ID_HEADER: &str = "x-document-storage-service-user-id";
/// Rejection returned when request credentials cannot authorize a user.
-pub type MacroAuthorizationRejection = (StatusCode, Json<ErrorResponse<'static>>);
+#[derive(Clone, Debug)]
+pub struct MacroAuthorizationRejection {
+ /// HTTP status returned to the client.
+ pub status: StatusCode,
+ /// Client-safe error message returned in the response body.
+ pub message: Cow<'static, str>,
+}
+
+impl fmt::Display for MacroAuthorizationRejection {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str(&self.message)
+ }
+}
+
+impl std::error::Error for MacroAuthorizationRejection {}
+
+impl IntoResponse for MacroAuthorizationRejection {
+ fn into_response(self) -> Response {
+ let Self { status, message } = self;
+ (status, Json(ErrorResponse { message })).into_response()
+ }
+}
/// Axum state containing the service used by authorization extractors.
pub struct MacroAuthorizationState<Svc> {
@@ -431,10 +453,8 @@ fn internal_authorization_rejection(
}
fn rejection(message: &'static str) -> MacroAuthorizationRejection {
- (
- StatusCode::UNAUTHORIZED,
- Json(ErrorResponse {
- message: message.into(),
- }),
- )
+ MacroAuthorizationRejection {
+ status: StatusCode::UNAUTHORIZED,
+ message: message.into(),
+ }
}
diff --git a/crates/macro_authorization/src/inbound/axum/test.rs b/crates/macro_authorization/src/inbound/axum/test.rs
index 9c4a02ccf3..0ee6741b42 100644
--- a/crates/macro_authorization/src/inbound/axum/test.rs
+++ b/crates/macro_authorization/src/inbound/axum/test.rs
@@ -1,10 +1,14 @@
-use std::sync::{Arc, Mutex};
+use std::{
+ borrow::Cow,
+ sync::{Arc, Mutex},
+};
use ::axum::{
Json, Router,
body::Body,
extract::FromRef,
http::{HeaderValue, Request, StatusCode},
+ response::IntoResponse,
routing::get,
};
use http_body_util::BodyExt;
@@ -182,6 +186,50 @@ fn empty_body(request: ::axum::http::request::Builder) -> Request<Body> {
fn assert_clone_without_service_clone<T: Clone>() {}
+fn assert_display_and_error<T: std::fmt::Display + std::error::Error>() {}
+
+#[test]
+fn rejection_is_displayable_error_with_client_safe_message() {
+ assert_display_and_error::<MacroAuthorizationRejection>();
+
+ let rejection = MacroAuthorizationRejection {
+ status: StatusCode::INTERNAL_SERVER_ERROR,
+ message: Cow::Borrowed("client-safe message"),
+ };
+
+ assert_eq!(rejection.to_string(), "client-safe message");
+}
+
+#[tokio::test]
+async fn rejection_response_preserves_status_and_cow_message() {
+ let cases = [
+ MacroAuthorizationRejection {
+ status: StatusCode::IM_A_TEAPOT,
+ message: Cow::Borrowed("borrowed message"),
+ },
+ MacroAuthorizationRejection {
+ status: StatusCode::FORBIDDEN,
+ message: Cow::Owned("owned message".to_string()),
+ },
+ ];
+
+ for rejection in cases {
+ let expected_status = rejection.status;
+ let expected_body = format!(r#"{{"message":"{}"}}"#, rejection.message);
+ let response = rejection.into_response();
+ let status = response.status();
+ let body = response
+ .into_body()
+ .collect()
+ .await
+ .expect("rejection response body should be readable")
+ .to_bytes();
+
+ assert_eq!(status, expected_status);
+ assert_eq!(body.as_ref(), expected_body.as_bytes());
+ }
+}
+
#[test]
fn state_and_extractors_are_clone_without_requiring_service_clone() {
struct NotClone;
diff --git a/crates/properties/src/inbound/axum_router/extract.rs b/crates/properties/src/inbound/axum_router/extract.rs
index 1bd4ec039b..bafb1f5d40 100644
--- a/crates/properties/src/inbound/axum_router/extract.rs
+++ b/crates/properties/src/inbound/axum_router/extract.rs
@@ -58,11 +58,8 @@ pub enum ReceiptRejection {
}
impl From<MacroAuthorizationRejection> for ReceiptRejection {
- fn from((status, rejection): MacroAuthorizationRejection) -> Self {
- Self::Authorization {
- status,
- message: rejection.0.message,
- }
+ fn from(MacroAuthorizationRejection { status, message }: MacroAuthorizationRejection) -> Self {
+ Self::Authorization { status, message }
}
}
diff --git a/crates/soup/Cargo.toml b/crates/soup/Cargo.toml
index 4a91959908..3986134516 100644
--- a/crates/soup/Cargo.toml
+++ b/crates/soup/Cargo.toml
@@ -22,8 +22,8 @@ all = ["ai_tools", "axum", "inbound", "outbound", "ports"]
axum = [
"dep:axum",
"dep:axum-extra",
+ "dep:macro_authorization",
"dep:model-error-response",
- "dep:model_user",
"dep:utoipa",
"email/axum",
"email/inbound",
@@ -68,10 +68,10 @@ foreign_entity = { path = "../foreign_entity", default-features = false, feature
frecency = { path = "../frecency" }
indexmap = { workspace = true }
item_filters = { path = "../item_filters" }
+macro_authorization = { path = "../macro_authorization", default-features = false, features = ["axum"], optional = true }
macro_user_id = { path = "../macro_user_id" }
model-entity = { path = "../model-entity" }
model-error-response = { path = "../model-error-response", optional = true }
-model_user = { path = "../model_user", optional = true, features = ["axum"] }
models_grouping = { path = "../models_grouping" }
models_pagination = { path = "../models_pagination" }
models_properties = { path = "../models_properties" }
@@ -102,6 +102,7 @@ futures = { workspace = true }
http-body-util = { workspace = true }
item_filters = { path = "../item_filters", features = ["mock"] }
macro_db_migrator = { path = "../macro_db_migrator" }
+model_user = { path = "../model_user" }
mockall = { workspace = true }
ordered-float = { workspace = true }
rootcause = { workspace = true }
diff --git a/crates/soup/src/inbound/axum_router.rs b/crates/soup/src/inbound/axum_router.rs
index a55297d774..97967e41de 100644
--- a/crates/soup/src/inbound/axum_router.rs
+++ b/crates/soup/src/inbound/axum_router.rs
@@ -13,7 +13,7 @@ use axum::{
response::IntoResponse,
routing::{get, post},
};
-use axum_extra::{either::Either, extract::Cached};
+use axum_extra::either::Either;
use cowlike::CowLike;
use email::{
domain::{
@@ -27,7 +27,7 @@ use entity_access::{
models::{EntityAccessReceipt, MemberTeamRole},
ports::EntityAccessService,
},
- inbound::axum_extractors::OptionalMacroUserTeamExtractor,
+ inbound::axum_extractors::OptionalMacroUserTeamExtractorV2,
};
use filter_ast::{Expr, ExprFrame};
use item_filters::{
@@ -45,10 +45,12 @@ use item_filters::{
properties::{PropertiesLiteral, PropertyEntityType},
},
};
+use macro_authorization::{
+ MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState,
+};
use macro_user_id::user_id::MacroUserIdStr;
use model_entity::Entity;
use model_error_response::ErrorResponse;
-use model_user::axum_extractor::MacroUserExtractor;
use models_grouping::{GroupByField, GroupingConfig};
use models_pagination::{
CursorWithValAndFilter, Frecency, PaginatedOpaqueCursor, SimpleSortMethod, SortMethod,
@@ -383,53 +385,78 @@ impl SoupFavoritesReader for NoFavoritesReader {
}
/// Shared state for soup API routes.
-pub struct SoupRouterState<T, U, EAS> {
+pub struct SoupRouterState<T, U, EAS, Auth> {
service: Arc<T>,
email: EmailRouterState<U>,
entity_access_service: Arc<EAS>,
+ authorization: MacroAuthorizationState<Auth>,
favorites: Arc<dyn SoupFavoritesReader>,
}
-impl<T, U, EAS> Clone for SoupRouterState<T, U, EAS> {
+impl<T, U, EAS, Auth> Clone for SoupRouterState<T, U, EAS, Auth> {
fn clone(&self) -> Self {
Self {
service: self.service.clone(),
email: self.email.clone(),
entity_access_service: self.entity_access_service.clone(),
+ authorization: self.authorization.clone(),
favorites: self.favorites.clone(),
}
}
}
-impl<T, U, EAS> FromRef<SoupRouterState<T, U, EAS>> for EmailRouterState<U> {
- fn from_ref(input: &SoupRouterState<T, U, EAS>) -> Self {
+impl<T, U, EAS, Auth> FromRef<SoupRouterState<T, U, EAS, Auth>> for EmailRouterState<U> {
+ fn from_ref(input: &SoupRouterState<T, U, EAS, Auth>) -> Self {
input.email.clone()
}
}
-impl<T, U, EAS> FromRef<SoupRouterState<T, U, EAS>> for Arc<EAS> {
- fn from_ref(input: &SoupRouterState<T, U, EAS>) -> Self {
+impl<T, U, EAS, Auth> FromRef<SoupRouterState<T, U, EAS, Auth>> for Arc<EAS> {
+ fn from_ref(input: &SoupRouterState<T, U, EAS, Auth>) -> Self {
input.entity_access_service.clone()
}
}
-impl<T, U, EAS> SoupRouterState<T, U, EAS>
+impl<T, U, EAS, Auth> FromRef<SoupRouterState<T, U, EAS, Auth>> for MacroAuthorizationState<Auth> {
+ fn from_ref(input: &SoupRouterState<T, U, EAS, Auth>) -> Self {
+ input.authorization.clone()
+ }
+}
+
+impl<T, U, EAS, Auth> SoupRouterState<T, U, EAS, Auth>
where
T: SoupService,
U: EmailService,
- EAS: entity_access::domain::ports::EntityAccessService,
+ EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
- /// Creates router state from the soup service, email service, and entity access service.
- pub fn new(service: T, email: U, entity_access_service: Arc<EAS>) -> Self {
- Self::from_arc(Arc::new(service), email, entity_access_service)
+ /// Creates router state from the soup service, email service, entity access service, and authorization state.
+ pub fn new(
+ service: T,
+ email: U,
+ entity_access_service: Arc<EAS>,
+ authorization: MacroAuthorizationState<Auth>,
+ ) -> Self {
+ Self::from_arc(
+ Arc::new(service),
+ email,
+ entity_access_service,
+ authorization,
+ )
}
- /// Creates router state from a shared soup service, email service, and entity access service.
- pub fn from_arc(service: Arc<T>, email: U, entity_access_service: Arc<EAS>) -> Self {
+ /// Creates router state from shared soup and entity access services, an email service, and authorization state.
+ pub fn from_arc(
+ service: Arc<T>,
+ email: U,
+ entity_access_service: Arc<EAS>,
+ authorization: MacroAuthorizationState<Auth>,
+ ) -> Self {
SoupRouterState {
service,
email: EmailRouterState::new(email),
entity_access_service,
+ authorization,
favorites: Arc::new(NoFavoritesReader),
}
}
@@ -581,18 +608,22 @@ where
}
/// Builds the Axum router for soup HTTP endpoints.
-pub fn soup_router<T, U, EAS, S>(state: SoupRouterState<T, U, EAS>) -> Router<S>
+pub fn soup_router<T, U, EAS, Auth, S>(state: SoupRouterState<T, U, EAS, Auth>) -> Router<S>
where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
S: Send + Sync,
{
Router::new()
- .route("/soup", get(get_soup_handler))
- .route("/soup", post(post_soup_handler))
- .route("/soup/ast", post(post_soup_ast_handler))
- .route("/soup/ast/grouped", post(post_grouped_soup_ast_handler))
+ .route("/soup", get(get_soup_handler::<T, U, EAS, Auth>))
+ .route("/soup", post(post_soup_handler::<T, U, EAS, Auth>))
+ .route("/soup/ast", post(post_soup_ast_handler::<T, U, EAS, Auth>))
+ .route(
+ "/soup/ast/grouped",
+ post(post_grouped_soup_ast_handler::<T, U, EAS, Auth>),
+ )
.with_state(state)
}
@@ -704,14 +735,15 @@ impl IntoResponse for SoupHandlerErr {
}
}
-async fn fetch_caller_link_ids<T, U, EAS>(
- service: &SoupRouterState<T, U, EAS>,
+async fn fetch_caller_link_ids<T, U, EAS, Auth>(
+ service: &SoupRouterState<T, U, EAS, Auth>,
macro_user_id: &str,
) -> Result<Vec<Uuid>, SoupHandlerErr>
where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
let macro_id = MacroUserIdStr::parse_from_str(macro_user_id).map_err(|e| {
SoupHandlerErr::Internal(SoupErr::SoupDbErr(anyhow::anyhow!(
@@ -741,10 +773,10 @@ where
(status = 500, body=ErrorResponse),
)
)]
-pub async fn get_soup_handler<T, U, EAS>(
- State(service): State<SoupRouterState<T, U, EAS>>,
- Cached(MacroUserExtractor { macro_user_id, .. }): Cached<MacroUserExtractor>,
- team: OptionalMacroUserTeamExtractor<MemberTeamRole, EAS>,
+pub async fn get_soup_handler<T, U, EAS, Auth>(
+ State(service): State<SoupRouterState<T, U, EAS, Auth>>,
+ MacroAuthorizationExtractor { macro_user_id, .. }: MacroAuthorizationExtractor<Auth>,
+ team: OptionalMacroUserTeamExtractorV2<MemberTeamRole, EAS, Auth>,
Query(params): Query<Params>,
cursor: SoupCursor<EntityFilters>,
) -> Result<Json<PaginatedOpaqueCursor<SoupApiItem>>, SoupHandlerErr>
@@ -752,6 +784,7 @@ where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
let link_ids = fetch_caller_link_ids(&service, macro_user_id.as_ref()).await?;
// Team receipt is plumbed through even for GET so that paginating a
@@ -812,10 +845,10 @@ type SoupCursor<R> = axum_extra::either::Either<
)
)]
#[tracing::instrument(err, skip_all)]
-pub async fn post_soup_handler<T, U, EAS>(
- State(service): State<SoupRouterState<T, U, EAS>>,
- Cached(MacroUserExtractor { macro_user_id, .. }): Cached<MacroUserExtractor>,
- team: OptionalMacroUserTeamExtractor<MemberTeamRole, EAS>,
+pub async fn post_soup_handler<T, U, EAS, Auth>(
+ State(service): State<SoupRouterState<T, U, EAS, Auth>>,
+ MacroAuthorizationExtractor { macro_user_id, .. }: MacroAuthorizationExtractor<Auth>,
+ team: OptionalMacroUserTeamExtractorV2<MemberTeamRole, EAS, Auth>,
cursor: SoupCursor<EntityFilters>,
Json(PostSoupRequest {
filters,
@@ -827,6 +860,7 @@ where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
let link_ids = fetch_caller_link_ids(&service, macro_user_id.as_ref()).await?;
// Pass the raw extractor receipt through — `handle` resolves the
@@ -877,10 +911,10 @@ pub struct PostSoupAstRequest {
)
)]
#[tracing::instrument(err, skip_all)]
-pub async fn post_soup_ast_handler<T, U, EAS>(
- State(service): State<SoupRouterState<T, U, EAS>>,
- Cached(MacroUserExtractor { macro_user_id, .. }): Cached<MacroUserExtractor>,
- team: OptionalMacroUserTeamExtractor<MemberTeamRole, EAS>,
+pub async fn post_soup_ast_handler<T, U, EAS, Auth>(
+ State(service): State<SoupRouterState<T, U, EAS, Auth>>,
+ MacroAuthorizationExtractor { macro_user_id, .. }: MacroAuthorizationExtractor<Auth>,
+ team: OptionalMacroUserTeamExtractorV2<MemberTeamRole, EAS, Auth>,
cursor: SoupCursor<ApiEntityFilterAst>,
Json(PostSoupAstRequest {
filters,
@@ -892,6 +926,7 @@ where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
let link_ids = fetch_caller_link_ids(&service, macro_user_id.as_ref()).await?;
// Pass the raw extractor receipt through — `handle` resolves the
@@ -967,9 +1002,9 @@ enum GroupedSoupRequestMode {
)
)]
#[tracing::instrument(err, skip_all)]
-pub async fn post_grouped_soup_ast_handler<T, U, EAS>(
- State(service): State<SoupRouterState<T, U, EAS>>,
- Cached(MacroUserExtractor { macro_user_id, .. }): Cached<MacroUserExtractor>,
+pub async fn post_grouped_soup_ast_handler<T, U, EAS, Auth>(
+ State(service): State<SoupRouterState<T, U, EAS, Auth>>,
+ MacroAuthorizationExtractor { macro_user_id, .. }: MacroAuthorizationExtractor<Auth>,
cursor: Option<CursorWithValAndFilter<Uuid, SimpleSortMethod, EntityFilterAst>>,
Json(request): Json<PostGroupedSoupAstRequest>,
) -> Result<Json<GroupedSoupPage>, SoupHandlerErr>
@@ -977,6 +1012,7 @@ where
T: SoupService,
U: EmailService,
EAS: EntityAccessService,
+ Auth: MacroAuthorizationService,
{
let (filters, params, mode) = match request {
PostGroupedSoupAstRequest::Initial(request) => (
diff --git a/crates/soup/src/inbound/axum_router/tests.rs b/crates/soup/src/inbound/axum_router/tests.rs
index 159e552656..4380e81737 100644
--- a/crates/soup/src/inbound/axum_router/tests.rs
+++ b/crates/soup/src/inbound/axum_router/tests.rs
@@ -1,6 +1,6 @@
use axum::{
- Extension, Router,
- http::{Method, Request, StatusCode},
+ Router,
+ http::{Method, Request, StatusCode, header},
};
use chrono::{Duration, Utc};
use email::domain::{
@@ -10,12 +10,17 @@ use email::domain::{
use entity_access::domain::models::{BotId, EntityAccessReceipt, ViewAccessLevel};
use http_body_util::BodyExt;
use item_filters::EntityFilters;
+use macro_authorization::{
+ INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,
+ MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,
+};
use macro_user_id::{email::EmailStr, user_id::MacroUserIdStr};
use model_user::UserContext;
use models_pagination::{
CursorVal, CursorWithValAndFilter, Frecency, FrecencyValue, Identify, PaginateOn, Query,
SimpleSortMethod, SortOn, TypeEraseCursor,
};
+use rootcause::Report;
use serde::Serialize;
use serde_json::json;
use std::sync::Arc;
@@ -38,6 +43,9 @@ use crate::{
};
static CURSOR: &str = "eyJpZCI6ImUzNmM5MTJlLTU2M2MtNDIxZS1iMTAzLWE0YjAwY2ZmMzBlZSIsImxpbWl0IjoxMDAsInZhbCI6eyJzb3J0X3R5cGUiOiJ1cGRhdGVkX2F0IiwibGFzdF92YWwiOiIyMDI1LTExLTA3VDE5OjEyOjU5Ljc4MFoifSwiZmlsdGVyIjp7fX0=";
+const USER_ID: &str = "macro|[email protected]";
+const INTERNAL_USER_ID: &str = "macro|[email protected]";
+const VALID_INTERNAL_KEY: &str = "valid-internal-key";
#[derive(Debug)]
enum MockCursorKind {
@@ -49,6 +57,7 @@ enum MockCursorKind {
#[derive(Debug)]
struct MockSoupCall {
+ user_id: String,
soup_type: SoupType,
email_preview_view: PreviewView,
link_ids: Vec<Uuid>,
@@ -60,12 +69,21 @@ struct MockSoupCall {
#[derive(Clone)]
struct MockSoup {
called: Arc<std::sync::Mutex<Vec<MockSoupCall>>>,
+ succeeds: bool,
}
impl MockSoup {
fn new() -> Self {
- MockSoup {
+ Self {
called: Arc::new(std::sync::Mutex::new(Vec::new())),
+ succeeds: false,
+ }
+ }
+
+ fn succeeding() -> Self {
+ Self {
+ succeeds: true,
+ ..Self::new()
}
}
}
@@ -142,6 +160,7 @@ impl SoupService for MockSoup {
MockCursorKind::FrecencyCursor
}
};
+ let user_id = req.user.to_string();
let soup_type = req.soup_type;
let email_preview_view = req.email_preview_view.clone();
let link_ids = req.link_ids.clone();
@@ -149,6 +168,7 @@ impl SoupService for MockSoup {
let expanded_filter = serde_json::to_value(req.into_ast()?.cursor.filter()).unwrap();
let mut guard = self.called.lock().unwrap();
guard.push(MockSoupCall {
+ user_id,
soup_type,
email_preview_view,
link_ids,
@@ -156,7 +176,15 @@ impl SoupService for MockSoup {
filter,
expanded_filter,
});
- Err(SoupErr::SoupDbErr(anyhow::anyhow!("Not implemented")))
+ drop(guard);
+
+ if self.succeeds {
+ Ok(either::Either::Left(
+ models_pagination::Paginated::from_parts(Vec::new(), None),
+ ))
+ } else {
+ Err(SoupErr::SoupDbErr(anyhow::anyhow!("Not implemented")))
+ }
}
async fn get_user_soup_grouped(
@@ -467,41 +495,141 @@ impl entity_access::domain::ports::EntityAccessService for MockEntityAccess {
}
}
-fn mock_router() -> Router {
- soup_router(SoupRouterState::new(
- MockSoup::new(),
- MockEmail,
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
+#[derive(Clone)]
+struct FakeAuthorizationService;
+
+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 != VALID_INTERNAL_KEY {
+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
+ }
+
+ Ok(claims.user_id.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(),
permissions: None,
organization_id: None,
- }))
+ }
+}
+
+type MockRouterState<T, U> = SoupRouterState<T, U, MockEntityAccess, FakeAuthorizationService>;
+
+fn mock_router_state<T, U>(service: T, email: U) -> MockRouterState<T, U>
+where
+ T: SoupService,
+ U: EmailService,
+{
+ SoupRouterState::new(
+ service,
+ email,
+ Arc::new(MockEntityAccess),
+ MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),
+ )
+}
+
+fn mock_router_with<T, U>(service: T, email: U) -> Router
+where
+ T: SoupService,
+ U: EmailService,
+{
+ soup_router(mock_router_state(service, email))
+}
+
+fn mock_router() -> Router {
+ mock_router_with(MockSoup::new(), MockEmail)
+}
+
+fn authenticated_request() -> axum::http::request::Builder {
+ Request::builder().header(header::AUTHORIZATION, "Bearer valid")
+}
+
+async fn send_json(
+ router: Router,
+ request: Request<axum::body::Body>,
+) -> (StatusCode, serde_json::Value) {
+ let response = router.oneshot(request).await.unwrap();
+ let status = response.status();
+ let bytes = response.into_body().collect().await.unwrap().to_bytes();
+ let body = serde_json::from_slice(&bytes).unwrap();
+ (status, body)
}
#[tokio::test]
async fn it_should_deserialize_empty_filter() {
- let router = mock_router();
-
- let request = Request::builder()
+ let request = authenticated_request()
.uri(format!("/soup?cursor={CURSOR}"))
.body(axum::body::Body::empty())
.unwrap();
- let res = router.oneshot(request).await.unwrap();
- assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
- let bytes = res.into_body().collect().await.unwrap().to_bytes();
- let json: serde_json::Value = serde_json::from_slice(bytes.as_ref()).unwrap();
+ let (status, body) = send_json(mock_router(), request).await;
+ assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(
- json,
+ body,
json!({
"message": "An internal server error has occurred"
})
);
}
+#[tokio::test]
+async fn no_credentials_returns_unauthorized_json() {
+ let request = Request::get(format!("/soup?cursor={CURSOR}"))
+ .body(axum::body::Body::empty())
+ .unwrap();
+
+ let (status, body) = send_json(mock_router(), request).await;
+ assert_eq!(status, StatusCode::UNAUTHORIZED);
+ assert_eq!(body, json!({ "message": "unauthorized" }));
+}
+
+#[tokio::test]
+async fn garbage_bearer_returns_unauthorized_json() {
+ let request = Request::get(format!("/soup?cursor={CURSOR}"))
+ .header(header::AUTHORIZATION, "Bearer garbage")
+ .body(axum::body::Body::empty())
+ .unwrap();
+
+ let (status, body) = send_json(mock_router(), request).await;
+ assert_eq!(status, StatusCode::UNAUTHORIZED);
+ assert_eq!(body, json!({ "message": "unauthorized" }));
+}
+
+#[tokio::test]
+async fn internal_credentials_use_the_acting_user() {
+ let soup = MockSoup::succeeding();
+ let calls = soup.called.clone();
+ let request = Request::get(format!("/soup?cursor={CURSOR}"))
+ .header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
+ .header(INTERNAL_MACRO_USER_ID_HEADER, INTERNAL_USER_ID)
+ .body(axum::body::Body::empty())
+ .unwrap();
+
+ let (status, body) = send_json(mock_router_with(soup, MockEmail), request).await;
+ assert_eq!(status, StatusCode::OK);
+ assert_eq!(body, json!({ "items": [], "next_cursor": null }));
+
+ let calls = calls.lock().unwrap();
+ assert_eq!(calls.len(), 1);
+ assert_eq!(calls[0].user_id, INTERNAL_USER_ID);
+}
+
struct MockEmailLinkResult {
get_link_result: Arc<
dyn Fn() -> Result<Option<email::domain::models::Link>, email::domain::models::EmailErr>
@@ -648,21 +776,14 @@ impl EmailService for MockEmailLinkResult {
async fn it_calls_soup_with_missing_link() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri(format!("/soup?cursor={CURSOR}"))
.body(axum::body::Body::empty())
.unwrap();
@@ -679,23 +800,16 @@ async fn it_calls_soup_with_missing_link() {
async fn it_does_not_call_soup_with_db_err() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| {
Err(EmailErr::RepoErr(anyhow::anyhow!("failed to fetch")))
}),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri(format!("/soup?cursor={CURSOR}"))
.body(axum::body::Body::empty())
.unwrap();
@@ -711,21 +825,14 @@ async fn it_does_not_call_soup_with_db_err() {
async fn it_loads_email_all_view() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri(format!("/soup?cursor={CURSOR}"))
.method(Method::POST)
.header("content-type", "application/json")
@@ -752,21 +859,14 @@ async fn it_loads_email_all_view() {
async fn it_loads_email_sent_view() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri(format!("/soup?cursor={CURSOR}"))
.method(Method::POST)
.header("content-type", "application/json")
@@ -793,21 +893,14 @@ async fn it_loads_email_sent_view() {
async fn it_parses_file_assoc_filters() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -833,21 +926,14 @@ async fn it_parses_file_assoc_filters() {
async fn cursor_with_assoc_works() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup.clone(),
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -899,7 +985,7 @@ async fn cursor_with_assoc_works() {
let cursor = res.type_erase().next_cursor.unwrap();
- let request2 = Request::builder()
+ let request2 = authenticated_request()
.uri(format!("/soup?cursor={cursor}"))
.method(Method::POST)
.header("content-type", "application/json")
@@ -908,19 +994,12 @@ async fn cursor_with_assoc_works() {
))
.unwrap();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
let _res = router.oneshot(request2).await.unwrap();
let guard2 = inner_counter.lock().unwrap();
@@ -932,21 +1011,14 @@ async fn cursor_with_assoc_works() {
async fn cursor_with_all_works() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup.clone(),
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -998,7 +1070,7 @@ async fn cursor_with_all_works() {
let cursor = res.type_erase().next_cursor.unwrap();
- let request2 = Request::builder()
+ let request2 = authenticated_request()
.uri(format!("/soup?cursor={cursor}"))
.method(Method::POST)
.header("content-type", "application/json")
@@ -1007,19 +1079,12 @@ async fn cursor_with_all_works() {
))
.unwrap();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
let _res = router.oneshot(request2).await.unwrap();
let guard2 = inner_counter.lock().unwrap();
@@ -1031,23 +1096,16 @@ async fn cursor_with_all_works() {
async fn it_parses_channel_filters() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup.clone(),
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
let uuid1 = Uuid::new_v4();
let uuid2 = Uuid::new_v4();
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1076,21 +1134,14 @@ async fn it_parses_channel_filters() {
async fn it_parses_notification_and_task_filters() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1189,21 +1240,14 @@ async fn it_can_filter_chat_owners() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1228,21 +1272,14 @@ async fn it_can_filter_chat_owners() {
async fn ast_endpoint_expands_file_assoc_pdf() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup/ast")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1275,22 +1312,15 @@ async fn ast_endpoint_expands_file_assoc_pdf() {
async fn ast_endpoint_passes_through_plain_document_literal() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
let doc_id = Uuid::new_v4();
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup/ast")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1323,21 +1353,14 @@ async fn ast_endpoint_passes_through_plain_document_literal() {
async fn ast_endpoint_passes_through_foreign_entity_filter() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup/ast")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1393,21 +1416,14 @@ fn ast_cursor_without_foreign_entity_filter_deserializes() {
async fn ast_endpoint_expands_file_assoc_image_to_or_tree() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup/ast")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1531,21 +1547,14 @@ async fn it_can_expand_assoc_ast() {
let soup = MockSoup::new();
let inner_counter = soup.called.clone();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup.clone(),
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
- let request = Request::builder()
+ let request = authenticated_request()
.uri("/soup/ast")
.method(Method::POST)
.header("content-type", "application/json")
@@ -1594,7 +1603,7 @@ async fn it_can_expand_assoc_ast() {
let cursor = res.type_erase().next_cursor.unwrap();
- let request2 = Request::builder()
+ let request2 = authenticated_request()
.uri(format!("/soup/ast?cursor={cursor}"))
.method(Method::POST)
.header("content-type", "application/json")
@@ -1603,19 +1612,12 @@ async fn it_can_expand_assoc_ast() {
))
.unwrap();
- let router: Router = soup_router(SoupRouterState::new(
+ let router: Router = mock_router_with(
soup,
MockEmailLinkResult {
get_link_result: Arc::new(|| Ok(None)),
},
- Arc::new(MockEntityAccess),
- ))
- .layer(Extension(UserContext {
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "1234".to_string(),
- permissions: None,
- organization_id: None,
- }));
+ );
let _res = router.oneshot(request2).await.unwrap();
diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rs
index d8de494421..f243a15908 100644
--- a/crates/teams/src/inbound/axum_router/test.rs
+++ b/crates/teams/src/inbound/axum_router/test.rs
@@ -4,7 +4,7 @@ use std::{
};
use axum::{
- Json, Router,
+ Router,
body::{Body, to_bytes},
http::{Request, StatusCode, header},
response::IntoResponse,
@@ -18,14 +18,14 @@ use entity_access::domain::{
};
use macro_authorization::{
INTERNAL_API_KEY_HEADER, INTERNAL_MACRO_USER_ID_HEADER, InternalIdentityClaims,
- MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,
+ MacroAuthorizationError, MacroAuthorizationRejection, MacroAuthorizationService,
+ MacroAuthorizationState,
};
use macro_user_id::{
email::Email,
lowercased::Lowercase,
user_id::{MacroUserId, MacroUserIdStr},
};
-use model_error_response::ErrorResponse;
use model_user::UserContext;
use roles_and_permissions::domain::model::PermissionId;
use rootcause::Report;
@@ -646,12 +646,10 @@ async fn teams_router_uses_entity_access_team_receipts() {
#[tokio::test]
async fn premium_user_authorization_rejection_preserves_response() {
- let rejection = PremiumUserRejection::Authorization((
- StatusCode::FORBIDDEN,
- Json(ErrorResponse {
- message: "authorization denied".into(),
- }),
- ));
+ let rejection = PremiumUserRejection::Authorization(MacroAuthorizationRejection {
+ status: StatusCode::FORBIDDEN,
+ message: "authorization denied".into(),
+ });
let (status, body, _) = response_parts(rejection).await;
assert_eq!(status, StatusCode::FORBIDDEN);
diff --git a/services/document_storage_service/src/api/context.rs b/services/document_storage_service/src/api/context.rs
index 3aba0be10c..7d140aad9c 100644
--- a/services/document_storage_service/src/api/context.rs
+++ b/services/document_storage_service/src/api/context.rs
@@ -142,7 +142,8 @@ pub(crate) type DssSoupService = SoupImpl<
ForeignEntityServiceType,
>;
-type DssSoupState = SoupRouterState<DssSoupService, DssEmailService, EntityAccessService>;
+type DssSoupState =
+ SoupRouterState<DssSoupService, DssEmailService, EntityAccessService, AuthorizationService>;
/// GraphQL Soup schema wired to the DSS services; the `ApiContext` state
/// parameter lets GraphQL resolvers run the same axum extractors as the REST
@@ -152,6 +153,7 @@ pub(crate) type DssGraphqlSoupSchema = complete_graph::SharedSoupSchema<
DssSoupService,
DssEmailService,
EntityAccessService,
+ AuthorizationService,
ApiContext,
complete_graph::PropertiesEntityPropertyWriter<PropertiesService, EntityAccessService>,
Arc<ai_tools::ToolNotificationService>,
@@ -480,8 +482,8 @@ impl FromRef<ApiContext> for SearchHandlerState {
}
/// `#[derive(FromRef)]` only exposes direct field types, so hand the email
-/// router state out of the nested soup router state for extractors like
-/// `MultiEmailLinkExtractor` that key off `EmailRouterState`.
+/// router state out of the nested soup router state for email-link extractors
+/// that key off `EmailRouterState`.
impl FromRef<ApiContext>
for email::inbound::axum::previews_router::EmailRouterState<DssEmailService>
{
diff --git a/services/document_storage_service/src/main.rs b/services/document_storage_service/src/main.rs
index 0d4eaddc39..fd649fce36 100644
--- a/services/document_storage_service/src/main.rs
+++ b/services/document_storage_service/src/main.rs
@@ -853,6 +853,7 @@ async fn main() -> anyhow::Result<()> {
soup_service.clone(),
email_service,
entity_access_service.clone(),
+ authorization_state.clone(),
)
.with_favorites_reader(Arc::new(
service::soup_favorites_reader::DssSoupFavoritesReader(favorites_service.clone()),