Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(soup): macro authorization (#4989)
Will Hutchinsonabb678d977e1
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 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.lockindex 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.tomlindex 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.rsindex 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>whereS: 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>whereS: 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>whereS: 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>whereS: 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 @@ wherectx: &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 @@ wherectx: &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.rsindex 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::SoupPropertiesFiSoupItem::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.rsindex 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.tomlindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.tomlindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.tomlindex 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, featuresfilter_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.rsindex 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>>whereS: 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 @@ whereS: 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.rsindex 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-servicepub 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.rsindex 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.rsindex 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.tomlindex 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, featurefrecency = { 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.rsindex 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>whereT: 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>whereT: 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>whereT: 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 @@ whereT: 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 @@ whereT: 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 @@ whereT: 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 @@ whereT: 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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()),