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(initiatives): crates/initiative inbound axum router handlers middleware router tests (#6452)
Will Hutchinson1e24ee9f5661
diff --git a/Cargo.lock b/Cargo.lockindex 563676c9a5..2bcfcf65e8 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -8782,6 +8782,7 @@ dependencies = ["chrono","entity_access","entity_access_db_utils",+ "http-body-util","macro_authorization","macro_db_migrator","macro_user_id",@@ -8789,6 +8790,7 @@ dependencies = ["mockall","model-entity","model-error-response",+ "model_user","models_permissions","rootcause","serde",@@ -8797,6 +8799,7 @@ dependencies = ["sqlx","thiserror 2.0.18","tokio",+ "tower 0.5.3","tracing","unicode-segmentation","utoipa",diff --git a/crates/initiative/Cargo.toml b/crates/initiative/Cargo.tomlindex 489d569302..8593a4a4c0 100644--- a/crates/initiative/Cargo.toml+++ b/crates/initiative/Cargo.toml@@ -52,6 +52,9 @@ mockall = { workspace = true }[dev-dependencies]anyhow = { workspace = true }+http-body-util = { workspace = true }macro_db_migrator = { path = "../macro_db_migrator" }+model_user = { path = "../model_user" }serde_json = { workspace = true }tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }+tower = { workspace = true }diff --git a/crates/initiative/src/inbound.rs b/crates/initiative/src/inbound.rsindex 74ab3f2bfd..8f92e78fa1 100644--- a/crates/initiative/src/inbound.rs+++ b/crates/initiative/src/inbound.rs@@ -1 +1,3 @@//! Inbound (driving) adapters for initiatives.++pub mod axum_router;diff --git a/crates/initiative/src/inbound/axum_router.rs b/crates/initiative/src/inbound/axum_router.rsnew file mode 100644index 0000000000..f8e3ba4290--- /dev/null+++ b/crates/initiative/src/inbound/axum_router.rs@@ -0,0 +1,237 @@+//! Axum router for initiative endpoints.++#[cfg(test)]+mod test;++pub mod assign_tasks;+pub mod create;+pub mod delete;+pub mod get;+pub mod list;+pub mod unassign_task;+pub mod update;++use std::str::FromStr;+use std::sync::Arc;++use axum::{+ Json, Router,+ body::Body,+ extract::{FromRef, Path, State},+ http::{Request, StatusCode},+ middleware::{self, Next},+ response::IntoResponse,+ routing::{self, put},+};+use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};+use model_error_response::ErrorResponse;+use serde::{Deserialize, Serialize};++pub use self::{+ assign_tasks::assign_initiative_tasks_handler, create::create_initiative_handler,+ delete::delete_initiative_handler, get::get_initiative_handler, list::list_initiatives_handler,+ unassign_task::unassign_initiative_task_handler, update::update_initiative_handler,+};+use crate::domain::{+ models::{InitiativeBasic, InitiativeError, InitiativeId},+ ports::InitiativeService,+};++/// Router state for initiative endpoints.+pub struct InitiativeRouterState<S, Eas, Auth> {+ service: Arc<S>,+ entity_access_service: Arc<Eas>,+ authorization_state: MacroAuthorizationState<Auth>,+}++impl<S, Eas, Auth> Clone for InitiativeRouterState<S, Eas, Auth> {+ fn clone(&self) -> Self {+ Self {+ service: self.service.clone(),+ entity_access_service: self.entity_access_service.clone(),+ authorization_state: self.authorization_state.clone(),+ }+ }+}++impl<S, Eas, Auth> InitiativeRouterState<S, Eas, Auth>+where+ S: InitiativeService,+ Eas: EntityAccessService,+{+ /// Create router state from shared service references and authorization state.+ pub fn new(+ service: Arc<S>,+ entity_access_service: Arc<Eas>,+ authorization_state: MacroAuthorizationState<Auth>,+ ) -> Self {+ Self {+ service,+ entity_access_service,+ authorization_state,+ }+ }+}++impl<S, Eas, Auth> FromRef<InitiativeRouterState<S, Eas, Auth>> for Arc<Eas> {+ fn from_ref(state: &InitiativeRouterState<S, Eas, Auth>) -> Self {+ state.entity_access_service.clone()+ }+}++impl<S, Eas, Auth> FromRef<InitiativeRouterState<S, Eas, Auth>> for MacroAuthorizationState<Auth> {+ fn from_ref(state: &InitiativeRouterState<S, Eas, Auth>) -> Self {+ state.authorization_state.clone()+ }+}++/// Successful mutation with no payload.+#[derive(Debug, Clone, Copy, Serialize, utoipa::ToSchema)]+pub struct GenericSuccessResponse {+ /// Whether the mutation succeeded.+ pub success: bool,+}++/// Path parameters for `{initiative_id}` routes.+#[derive(Debug, Deserialize, utoipa::IntoParams)]+#[into_params(parameter_in = Path)]+pub struct InitiativeIdParams {+ /// Initiative identifier.+ pub initiative_id: String,+}++/// Path parameters for unassigning one task.+#[derive(Debug, Deserialize, utoipa::IntoParams)]+#[into_params(parameter_in = Path)]+pub struct UnassignTaskParams {+ /// Initiative identifier.+ pub initiative_id: String,+ /// Task identifier.+ pub task_id: String,+}++/// Build the initiative router.+///+/// Nested under `/initiatives` by the composition root.+pub fn initiative_router<S, Eas, Auth, T>(state: InitiativeRouterState<S, Eas, Auth>) -> Router<T>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+ T: Send + Sync + 'static,+{+ let initiative_id_routes = Router::new()+ .route(+ "/{initiative_id}",+ routing::get(get_initiative_handler::<S, Eas, Auth>)+ .patch(update_initiative_handler::<S, Eas, Auth>)+ .delete(delete_initiative_handler::<S, Eas, Auth>),+ )+ .route(+ "/{initiative_id}/tasks",+ put(assign_initiative_tasks_handler::<S, Eas, Auth>),+ )+ .route(+ "/{initiative_id}/tasks/{task_id}",+ routing::delete(unassign_initiative_task_handler::<S, Eas, Auth>),+ )+ .layer(middleware::from_fn_with_state(+ state.clone(),+ ensure_initiative_exists::<S, Eas, Auth>,+ ));++ Router::new()+ .merge(initiative_id_routes)+ .route(+ "/",+ routing::get(list_initiatives_handler::<S, Eas, Auth>)+ .post(create_initiative_handler::<S, Eas, Auth>),+ )+ .with_state(state)+}++#[tracing::instrument(skip(state, request, next))]+async fn ensure_initiative_exists<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ Path(InitiativeIdParams { initiative_id }): Path<InitiativeIdParams>,+ mut request: Request<Body>,+ next: Next,+) -> impl IntoResponse+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let id = match InitiativeId::from_str(&initiative_id) {+ Ok(id) => id,+ Err(_) => {+ return (+ StatusCode::BAD_REQUEST,+ Json(ErrorResponse {+ message: "invalid initiative id".into(),+ }),+ )+ .into_response();+ }+ };++ let basic: InitiativeBasic = match state.service.internal_get_basic(id).await {+ Ok(basic) => basic,+ Err(InitiativeError::NotFound) => {+ return (+ StatusCode::NOT_FOUND,+ Json(ErrorResponse {+ message: format!("initiative with id \"{initiative_id}\" was not found").into(),+ }),+ )+ .into_response();+ }+ Err(error) => {+ tracing::error!(+ error=?error,+ initiative_id=?initiative_id,+ "unable to check if initiative exists"+ );+ return (+ StatusCode::INTERNAL_SERVER_ERROR,+ Json(ErrorResponse {+ message: "unknown error occurred".into(),+ }),+ )+ .into_response();+ }+ };++ request.extensions_mut().insert(basic);+ next.run(request).await.into_response()+}++impl IntoResponse for InitiativeError {+ fn into_response(self) -> axum::response::Response {+ let status_code = match &self {+ InitiativeError::NotFound => StatusCode::NOT_FOUND,+ InitiativeError::Unauthorized => StatusCode::UNAUTHORIZED,+ InitiativeError::BadRequest(_) => StatusCode::BAD_REQUEST,+ InitiativeError::Conflict(_) => StatusCode::CONFLICT,+ InitiativeError::NameTooLong { .. } => StatusCode::UNPROCESSABLE_ENTITY,+ InitiativeError::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,+ };++ let message = match &self {+ InitiativeError::Internal(e) => {+ tracing::error!(error=?e, "initiative request failed");+ "internal server error".to_string()+ }+ error => error.to_string(),+ };++ (+ status_code,+ Json(ErrorResponse {+ message: message.into(),+ }),+ )+ .into_response()+ }+}diff --git a/crates/initiative/src/inbound/axum_router/assign_tasks.rs b/crates/initiative/src/inbound/axum_router/assign_tasks.rsnew file mode 100644index 0000000000..96d16602a8--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/assign_tasks.rs@@ -0,0 +1,91 @@+//! Handler for assigning tasks to an initiative.++use axum::{Json, extract::State};+use entity_access::domain::models::{+ AccessError, EditAccessLevel, EntityAccessReceipt, EntityType,+};+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::InitiativeAccessExtractor;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService, UserOrInternal};+use model_error_response::ErrorResponse;++use super::{InitiativeIdParams, InitiativeRouterState};+use crate::domain::{+ models::{AssignTasksRequest, AssignTasksResponse, InitiativeError, TaskAssignment},+ ports::InitiativeService,+};++/// Assign tasks the caller can edit.+#[utoipa::path(+ put,+ tag = "initiative",+ operation_id = "assign_initiative_tasks",+ path = "/initiatives/{initiative_id}/tasks",+ params(InitiativeIdParams),+ request_body = AssignTasksRequest,+ responses(+ (status = 200, body = AssignTasksResponse),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn assign_initiative_tasks_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ access: InitiativeAccessExtractor<EditAccessLevel, Eas, Auth>,+ user: MacroAuthorizationExtractor<Auth, UserOrInternal>,+ Json(request): Json<AssignTasksRequest>,+) -> Result<Json<AssignTasksResponse>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let user_id = &user.authorization.user.macro_user_id;+ let user_org_id = user+ .authorization+ .user+ .user_context+ .organization_id+ .map(i64::from);++ let mut assignments = Vec::with_capacity(request.task_ids.len());+ for task_id in request.task_ids {+ let result = state+ .entity_access_service+ .generate_entity_access_receipt::<EditAccessLevel>(+ user_id,+ user_org_id,+ &task_id,+ EntityType::Document,+ )+ .await;+ assignments.push(task_assignment_from_access(task_id, result)?);+ }++ let response = state+ .service+ .assign_tasks(access.entity_access_receipt, assignments)+ .await?;+ Ok(Json(response))+}++fn task_assignment_from_access(+ task_id: String,+ result: Result<EntityAccessReceipt<EditAccessLevel>, AccessError>,+) -> Result<TaskAssignment, InitiativeError> {+ match result {+ Ok(_) => Ok(TaskAssignment::Candidate { task_id }),+ Err(AccessError::Unauthorized | AccessError::UnauthorizedWithMessage(_)) => {+ Ok(TaskAssignment::SkippedNoPermission { task_id })+ }+ Err(AccessError::NotFound(_) | AccessError::BadRequest(_)) => {+ Ok(TaskAssignment::NotFound { task_id })+ }+ Err(other) => Err(InitiativeError::Internal(+ rootcause::Report::new(other).into_dynamic(),+ )),+ }+}diff --git a/crates/initiative/src/inbound/axum_router/create.rs b/crates/initiative/src/inbound/axum_router/create.rsnew file mode 100644index 0000000000..f8d3ff3796--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/create.rs@@ -0,0 +1,46 @@+//! Handler for creating an initiative.++use axum::{Json, extract::State};+use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService, UserOrInternal};+use model_error_response::ErrorResponse;++use super::InitiativeRouterState;+use crate::domain::{+ models::{CreateInitiativeRequest, InitiativeDetail, InitiativeError},+ ports::InitiativeService,+};++/// Create an initiative owned by the caller.+#[utoipa::path(+ post,+ tag = "initiative",+ operation_id = "create_initiative",+ path = "/initiatives",+ request_body = CreateInitiativeRequest,+ responses(+ (status = 200, body = InitiativeDetail),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 409, body = ErrorResponse),+ (status = 422, description = "Name exceeds the maximum length", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn create_initiative_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ user: MacroAuthorizationExtractor<Auth, UserOrInternal>,+ Json(request): Json<CreateInitiativeRequest>,+) -> Result<Json<InitiativeDetail>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let detail = state+ .service+ .create(&user.authorization.user.macro_user_id, request)+ .await?;+ Ok(Json(detail))+}diff --git a/crates/initiative/src/inbound/axum_router/delete.rs b/crates/initiative/src/inbound/axum_router/delete.rsnew file mode 100644index 0000000000..2fd39a1e22--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/delete.rs@@ -0,0 +1,40 @@+//! Handler for deleting an initiative.++use axum::{Json, extract::State};+use entity_access::domain::models::OwnerAccessLevel;+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::InitiativeAccessExtractor;+use macro_authorization::MacroAuthorizationService;+use model_error_response::ErrorResponse;++use super::{GenericSuccessResponse, InitiativeIdParams, InitiativeRouterState};+use crate::domain::{models::InitiativeError, ports::InitiativeService};++/// Delete the initiative the caller owns.+#[utoipa::path(+ delete,+ tag = "initiative",+ operation_id = "delete_initiative",+ path = "/initiatives/{initiative_id}",+ params(InitiativeIdParams),+ responses(+ (status = 200, body = GenericSuccessResponse),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn delete_initiative_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ access: InitiativeAccessExtractor<OwnerAccessLevel, Eas, Auth>,+) -> Result<Json<GenericSuccessResponse>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ state.service.delete(access.entity_access_receipt).await?;+ Ok(Json(GenericSuccessResponse { success: true }))+}diff --git a/crates/initiative/src/inbound/axum_router/get.rs b/crates/initiative/src/inbound/axum_router/get.rsnew file mode 100644index 0000000000..af11132c4a--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/get.rs@@ -0,0 +1,43 @@+//! Handler for fetching one initiative.++use axum::{Json, extract::State};+use entity_access::domain::models::ViewAccessLevel;+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::InitiativeAccessExtractor;+use macro_authorization::MacroAuthorizationService;+use model_error_response::ErrorResponse;++use super::{InitiativeIdParams, InitiativeRouterState};+use crate::domain::{+ models::{InitiativeDetail, InitiativeError},+ ports::InitiativeService,+};++/// Fetch one initiative the caller can view.+#[utoipa::path(+ get,+ tag = "initiative",+ operation_id = "get_initiative",+ path = "/initiatives/{initiative_id}",+ params(InitiativeIdParams),+ responses(+ (status = 200, body = InitiativeDetail),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn get_initiative_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ access: InitiativeAccessExtractor<ViewAccessLevel, Eas, Auth>,+) -> Result<Json<InitiativeDetail>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let detail = state.service.get(access.entity_access_receipt).await?;+ Ok(Json(detail))+}diff --git a/crates/initiative/src/inbound/axum_router/list.rs b/crates/initiative/src/inbound/axum_router/list.rsnew file mode 100644index 0000000000..0f3823f581--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/list.rs@@ -0,0 +1,41 @@+//! Handler for listing initiatives.++use axum::{Json, extract::State};+use entity_access::domain::ports::EntityAccessService;+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService, UserOrInternal};+use model_error_response::ErrorResponse;++use super::InitiativeRouterState;+use crate::domain::{+ models::{InitiativeError, InitiativeList},+ ports::InitiativeService,+};++/// List initiatives the caller can view.+#[utoipa::path(+ get,+ tag = "initiative",+ operation_id = "list_initiatives",+ path = "/initiatives",+ responses(+ (status = 200, body = InitiativeList),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn list_initiatives_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ user: MacroAuthorizationExtractor<Auth, UserOrInternal>,+) -> Result<Json<InitiativeList>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let list = state+ .service+ .list(&user.authorization.user.macro_user_id)+ .await?;+ Ok(Json(list))+}diff --git a/crates/initiative/src/inbound/axum_router/test.rs b/crates/initiative/src/inbound/axum_router/test.rsnew file mode 100644index 0000000000..23ea0084b1--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/test.rs@@ -0,0 +1,820 @@+use std::collections::HashMap;+use std::sync::{Arc, Mutex};++use axum::http::{StatusCode, header};+use chrono::{DateTime, TimeZone, Utc};+use entity_access::domain::models::{+ AccessError, AccessLevel, BotAccessScope, BotId, CallChannelInfo, EditAccessLevel, Entity,+ EntityAccessReceipt, EntityPermission, EntityType, OwnerAccessLevel, RequiredPermission,+ TeamRole, UserTeamInfo, ViewAccessLevel,+};+use entity_access::domain::ports::EntityAccessService;+use http_body_util::BodyExt;+use macro_authorization::{+ InternalIdentityClaims, MacroAuthorizationError, MacroAuthorizationService,+ MacroAuthorizationState,+};+use macro_user_id::cowlike::CowLike;+use macro_user_id::{+ lowercased::Lowercase,+ user_id::{MacroUserId, MacroUserIdStr},+};+use model_user::UserContext;+use models_permissions::share_permission::SharePermissionV2;+use rootcause::Report;+use tower::ServiceExt;+use uuid::Uuid;++use super::*;+use crate::domain::{+ models::{+ AssignTaskStatus, AssignTasksResponse, AssignTasksResult, CreateInitiativeRequest,+ InitiativeBasic, InitiativeDetail, InitiativeError, InitiativeId, InitiativeList,+ InitiativeSummary, MAX_INITIATIVE_NAME_GRAPHEMES, TaskAssignment, UpdateInitiativeRequest,+ },+ ports::InitiativeService,+};++const USER_ID: &str = "macro|[email protected]";+const VALID_JWT: &str = "valid";+const TASK_OK: &str = "task-ok";+const TASK_DENIED: &str = "task-denied";+const TASK_MISSING: &str = "task-missing";++fn existing_id() -> InitiativeId {+ InitiativeId::from_uuid(Uuid::from_u128(1))+}++fn unknown_id() -> InitiativeId {+ InitiativeId::from_uuid(Uuid::from_u128(99))+}++fn now() -> DateTime<Utc> {+ Utc.with_ymd_and_hms(2026, 9, 15, 12, 0, 0)+ .single()+ .expect("unambiguous instant")+}++fn user() -> MacroUserIdStr<'static> {+ MacroUserIdStr::parse_from_str(USER_ID)+ .expect("valid user id")+ .into_owned()+}++fn user_context() -> UserContext {+ UserContext {+ user_id: USER_ID.to_string(),+ fusion_user_id: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb".to_string(),+ permissions: None,+ organization_id: Some(42),+ }+}++fn share_permission() -> SharePermissionV2 {+ SharePermissionV2::new_initiative_share_permission(None)+}++fn sample_basic() -> InitiativeBasic {+ InitiativeBasic {+ id: existing_id(),+ name: "Launch".to_string(),+ owner_id: user(),+ }+}++fn sample_detail() -> InitiativeDetail {+ InitiativeDetail {+ id: existing_id(),+ name: "Launch".to_string(),+ description: None,+ owner_id: user(),+ member_ids: Vec::new(),+ task_ids: Vec::new(),+ share_permission: share_permission(),+ user_access_level: AccessLevel::Edit,+ created_at: now(),+ updated_at: now(),+ }+}++fn sample_list() -> InitiativeList {+ InitiativeList {+ initiatives: vec![InitiativeSummary {+ id: existing_id(),+ name: "Launch".to_string(),+ description: None,+ updated_at: now(),+ }],+ }+}++#[derive(Clone)]+struct FakeAuthorizationService;++impl MacroAuthorizationService for FakeAuthorizationService {+ async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {+ if jwt != VALID_JWT {+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));+ }+ Ok(user_context())+ }++ async fn authorize_internal(+ &self,+ _provided_key: &str,+ _claims: InternalIdentityClaims,+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {+ Err(Report::new(MacroAuthorizationError::InvalidCredentials))+ }+}++#[derive(Clone)]+struct FakeEntityAccessService {+ initiative_access: Option<AccessLevel>,+ document_denials: HashMap<String, fn() -> AccessError>,+}++impl FakeEntityAccessService {+ fn without_initiative_access() -> Self {+ Self {+ initiative_access: None,+ document_denials: HashMap::new(),+ }+ }++ fn denying_document(task_id: &str, denial: fn() -> AccessError) -> Self {+ let mut document_denials = HashMap::new();+ document_denials.insert(task_id.to_string(), denial);+ Self {+ initiative_access: Some(AccessLevel::Owner),+ document_denials,+ }+ }+}++impl Default for FakeEntityAccessService {+ fn default() -> Self {+ Self {+ initiative_access: Some(AccessLevel::Owner),+ document_denials: HashMap::new(),+ }+ }+}++impl EntityAccessService for FakeEntityAccessService {+ async fn generate_entity_access_receipt<T: RequiredPermission>(+ &self,+ user_id: &MacroUserId<Lowercase<'_>>,+ _user_org_id: Option<i64>,+ entity_id: &str,+ entity_type: EntityType,+ ) -> Result<EntityAccessReceipt<T>, AccessError> {+ if entity_type != EntityType::Document {+ return Err(AccessError::internal("test access failure"));+ }+ if let Some(denial) = self.document_denials.get(entity_id) {+ return Err(denial());+ }+ EntityAccessReceipt::try_new_authenticated_user(+ MacroUserIdStr::parse_from_str(USER_ID)+ .expect("valid user id")+ .clone(),+ Entity {+ entity_id: entity_id.to_string(),+ entity_type,+ },+ EntityPermission::AccessLevel {+ access_level: AccessLevel::Edit,+ },+ )+ .inspect(|_| debug_assert_eq!(user_id.as_ref(), USER_ID))+ }++ async fn generate_bot_entity_access_receipt<T: RequiredPermission>(+ &self,+ _bot_id: BotId,+ _scope: BotAccessScope,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<EntityAccessReceipt<T>, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_access_level(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ entity_type: EntityType,+ ) -> Result<Option<AccessLevel>, AccessError> {+ if entity_type != EntityType::Initiative {+ return Err(AccessError::internal("test access failure"));+ }+ Ok(self.initiative_access)+ }++ async fn check_access(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ _required_level: AccessLevel,+ ) -> Result<AccessLevel, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn check_public_access(+ &self,+ _entity_id: &str,+ _entity_type: EntityType,+ _required_level: AccessLevel,+ ) -> Result<AccessLevel, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_entity_permission(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ _user_org_id: Option<i64>,+ ) -> Result<EntityPermission, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_crm_entity_permission_with_team(+ &self,+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<(EntityPermission, Uuid, TeamRole), AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_users_by_entity(+ &self,+ _entity_id: &str,+ _entity_type: EntityType,+ ) -> Result<Vec<MacroUserIdStr<'static>>, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_call_channel(+ &self,+ _call_id: &Uuid,+ ) -> Result<Option<CallChannelInfo>, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_call_channel_by_channel_id(+ &self,+ _channel_id: &Uuid,+ ) -> Result<Option<CallChannelInfo>, AccessError> {+ Err(AccessError::internal("test access failure"))+ }++ async fn get_user_team(+ &self,+ _user_id: &MacroUserId<Lowercase<'_>>,+ ) -> Result<Option<UserTeamInfo>, AccessError> {+ Err(AccessError::internal("test access failure"))+ }+}++#[derive(Debug, Clone, PartialEq)]+enum ServiceCall {+ List,+ Create { name: String },+ Get,+ Update,+ Assign(Vec<TaskAssignment>),+ Unassign { task_id: String },+ Delete,+}++#[derive(Clone, Default)]+struct FakeInitiativeService {+ calls: Arc<Mutex<Vec<ServiceCall>>>,+}++impl FakeInitiativeService {+ fn calls(&self) -> Vec<ServiceCall> {+ self.calls.lock().expect("call log poisoned").clone()+ }++ fn record(&self, call: ServiceCall) {+ self.calls.lock().expect("call log poisoned").push(call);+ }+}++fn reject_name(name: &str) -> Result<(), InitiativeError> {+ if name.chars().count() > MAX_INITIATIVE_NAME_GRAPHEMES {+ return Err(InitiativeError::NameTooLong {+ max: MAX_INITIATIVE_NAME_GRAPHEMES,+ });+ }+ Ok(())+}++impl InitiativeService for FakeInitiativeService {+ async fn create(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ request: CreateInitiativeRequest,+ ) -> Result<InitiativeDetail, InitiativeError> {+ reject_name(&request.name)?;+ self.record(ServiceCall::Create {+ name: request.name.clone(),+ });+ Ok(sample_detail())+ }++ async fn internal_get_basic(+ &self,+ id: InitiativeId,+ ) -> Result<InitiativeBasic, InitiativeError> {+ if id != existing_id() {+ return Err(InitiativeError::NotFound);+ }+ Ok(sample_basic())+ }++ async fn get(+ &self,+ _receipt: EntityAccessReceipt<ViewAccessLevel>,+ ) -> Result<InitiativeDetail, InitiativeError> {+ self.record(ServiceCall::Get);+ Ok(sample_detail())+ }++ async fn list(&self, _user_id: &MacroUserIdStr<'_>) -> Result<InitiativeList, InitiativeError> {+ self.record(ServiceCall::List);+ Ok(sample_list())+ }++ async fn update(+ &self,+ _receipt: EntityAccessReceipt<EditAccessLevel>,+ request: UpdateInitiativeRequest,+ ) -> Result<InitiativeDetail, InitiativeError> {+ if let Some(name) = &request.name {+ reject_name(name)?;+ }+ self.record(ServiceCall::Update);+ Ok(sample_detail())+ }++ async fn assign_tasks(+ &self,+ _receipt: EntityAccessReceipt<EditAccessLevel>,+ assignments: Vec<TaskAssignment>,+ ) -> Result<AssignTasksResponse, InitiativeError> {+ self.record(ServiceCall::Assign(assignments.clone()));+ Ok(AssignTasksResponse {+ results: assignments+ .into_iter()+ .map(|assignment| AssignTasksResult {+ status: match &assignment {+ TaskAssignment::Candidate { .. } => AssignTaskStatus::Assigned,+ TaskAssignment::NotFound { .. } => AssignTaskStatus::NotFound,+ TaskAssignment::SkippedNoPermission { .. } => {+ AssignTaskStatus::SkippedNoPermission+ }+ },+ task_id: assignment.task_id().to_string(),+ })+ .collect(),+ })+ }++ async fn unassign_task(+ &self,+ _receipt: EntityAccessReceipt<EditAccessLevel>,+ task_id: &str,+ ) -> Result<(), InitiativeError> {+ self.record(ServiceCall::Unassign {+ task_id: task_id.to_string(),+ });+ Ok(())+ }++ async fn delete(+ &self,+ _receipt: EntityAccessReceipt<OwnerAccessLevel>,+ ) -> Result<(), InitiativeError> {+ self.record(ServiceCall::Delete);+ Ok(())+ }+}++fn build_router(service: FakeInitiativeService, access: FakeEntityAccessService) -> axum::Router {+ initiative_router(InitiativeRouterState::new(+ Arc::new(service),+ Arc::new(access),+ MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),+ ))+}++fn authed(builder: axum::http::request::Builder) -> axum::http::request::Builder {+ builder.header(header::AUTHORIZATION, format!("Bearer {VALID_JWT}"))+}++fn json_body(value: serde_json::Value) -> axum::body::Body {+ axum::body::Body::from(value.to_string())+}++async fn read_json(response: axum::response::Response) -> serde_json::Value {+ let bytes = response+ .into_body()+ .collect()+ .await+ .expect("body should collect")+ .to_bytes();+ serde_json::from_slice(&bytes).expect("body should be json")+}++async fn send(+ router: axum::Router,+ request: axum::http::Request<axum::body::Body>,+) -> axum::response::Response {+ router+ .oneshot(request)+ .await+ .expect("router should respond")+}++#[tokio::test]+async fn unknown_initiative_id_is_404() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::get(format!("/{}", unknown_id())))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::NOT_FOUND);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "message": format!("initiative with id \"{}\" was not found", unknown_id())+ })+ );+ assert!(service.calls().is_empty());+}++#[tokio::test]+async fn invalid_initiative_id_is_400() {+ let response = send(+ build_router(+ FakeInitiativeService::default(),+ FakeEntityAccessService::default(),+ ),+ authed(axum::http::Request::get("/not-a-uuid"))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({ "message": "invalid initiative id" })+ );+}++#[tokio::test]+async fn no_access_on_an_existing_id_is_401() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(+ service.clone(),+ FakeEntityAccessService::without_initiative_access(),+ ),+ authed(axum::http::Request::get(format!("/{}", existing_id())))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "message": "User does not have access to the requested resource"+ })+ );+ assert!(service.calls().is_empty());+}++#[tokio::test]+async fn list_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::get("/"))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::to_value(sample_list()).expect("list json")+ );+ assert_eq!(service.calls(), vec![ServiceCall::List]);+}++#[tokio::test]+async fn create_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::post("/"))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "name": "Launch" })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::to_value(sample_detail()).expect("detail json")+ );+ assert_eq!(+ service.calls(),+ vec![ServiceCall::Create {+ name: "Launch".to_string()+ }]+ );+}++#[tokio::test]+async fn get_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::get(format!("/{}", existing_id())))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::to_value(sample_detail()).expect("detail json")+ );+ assert_eq!(service.calls(), vec![ServiceCall::Get]);+}++#[tokio::test]+async fn update_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::patch(format!("/{}", existing_id())))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "name": "Renamed" })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::to_value(sample_detail()).expect("detail json")+ );+ assert_eq!(service.calls(), vec![ServiceCall::Update]);+}++#[tokio::test]+async fn assign_tasks_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::put(format!(+ "/{}/tasks",+ existing_id()+ )))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "taskIds": [TASK_OK] })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "results": [{ "taskId": TASK_OK, "status": "assigned" }]+ })+ );+ assert_eq!(+ service.calls(),+ vec![ServiceCall::Assign(vec![TaskAssignment::Candidate {+ task_id: TASK_OK.to_string()+ }])]+ );+}++#[tokio::test]+async fn unassign_task_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::delete(format!(+ "/{}/tasks/{TASK_OK}",+ existing_id()+ )))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({ "success": true })+ );+ assert_eq!(+ service.calls(),+ vec![ServiceCall::Unassign {+ task_id: TASK_OK.to_string()+ }]+ );+}++#[tokio::test]+async fn delete_returns_200() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::delete(format!("/{}", existing_id())))+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({ "success": true })+ );+ assert_eq!(service.calls(), vec![ServiceCall::Delete]);+}++#[tokio::test]+async fn a_name_that_is_too_long_is_422() {+ let name = "x".repeat(MAX_INITIATIVE_NAME_GRAPHEMES + 1);+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(service.clone(), FakeEntityAccessService::default()),+ authed(axum::http::Request::post("/"))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "name": name })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({ "message": "name too long" })+ );+ assert!(service.calls().is_empty());+}++#[tokio::test]+async fn assign_unauthorized_is_skipped_no_permission() {+ let service = FakeInitiativeService::default();+ let response = send(+ build_router(+ service.clone(),+ FakeEntityAccessService::denying_document(TASK_DENIED, || AccessError::Unauthorized),+ ),+ authed(axum::http::Request::put(format!(+ "/{}/tasks",+ existing_id()+ )))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({+ "taskIds": [TASK_DENIED, TASK_OK]+ })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "results": [+ { "taskId": TASK_DENIED, "status": "skippedNoPermission" },+ { "taskId": TASK_OK, "status": "assigned" }+ ]+ })+ );+}++#[tokio::test]+async fn assign_unauthorized_with_message_is_skipped_no_permission() {+ let response = send(+ build_router(+ FakeInitiativeService::default(),+ FakeEntityAccessService::denying_document(TASK_DENIED, || {+ AccessError::UnauthorizedWithMessage("nope")+ }),+ ),+ authed(axum::http::Request::put(format!(+ "/{}/tasks",+ existing_id()+ )))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "taskIds": [TASK_DENIED] })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "results": [{ "taskId": TASK_DENIED, "status": "skippedNoPermission" }]+ })+ );+}++#[tokio::test]+async fn assign_not_found_is_not_found() {+ let response = send(+ build_router(+ FakeInitiativeService::default(),+ FakeEntityAccessService::denying_document(TASK_MISSING, || {+ AccessError::NotFound("task")+ }),+ ),+ authed(axum::http::Request::put(format!(+ "/{}/tasks",+ existing_id()+ )))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "taskIds": [TASK_MISSING] })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "results": [{ "taskId": TASK_MISSING, "status": "notFound" }]+ })+ );+}++#[tokio::test]+async fn assign_bad_request_is_not_found() {+ let response = send(+ build_router(+ FakeInitiativeService::default(),+ FakeEntityAccessService::denying_document(TASK_MISSING, || {+ AccessError::BadRequest("bad")+ }),+ ),+ authed(axum::http::Request::put(format!(+ "/{}/tasks",+ existing_id()+ )))+ .header(header::CONTENT_TYPE, "application/json")+ .body(json_body(serde_json::json!({ "taskIds": [TASK_MISSING] })))+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ read_json(response).await,+ serde_json::json!({+ "results": [{ "taskId": TASK_MISSING, "status": "notFound" }]+ })+ );+}++#[tokio::test]+async fn list_without_credentials_is_401() {+ let response = send(+ build_router(+ FakeInitiativeService::default(),+ FakeEntityAccessService::default(),+ ),+ axum::http::Request::get("/")+ .body(axum::body::Body::empty())+ .expect("request should build"),+ )+ .await;++ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);+}diff --git a/crates/initiative/src/inbound/axum_router/unassign_task.rs b/crates/initiative/src/inbound/axum_router/unassign_task.rsnew file mode 100644index 0000000000..5cbb1bd1de--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/unassign_task.rs@@ -0,0 +1,47 @@+//! Handler for unassigning one task from an initiative.++use axum::{+ Json,+ extract::{Path, State},+};+use entity_access::domain::models::EditAccessLevel;+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::InitiativeAccessExtractor;+use macro_authorization::MacroAuthorizationService;+use model_error_response::ErrorResponse;++use super::{GenericSuccessResponse, InitiativeRouterState, UnassignTaskParams};+use crate::domain::{models::InitiativeError, ports::InitiativeService};++/// Unassign one task the caller can edit.+#[utoipa::path(+ delete,+ tag = "initiative",+ operation_id = "unassign_initiative_task",+ path = "/initiatives/{initiative_id}/tasks/{task_id}",+ params(UnassignTaskParams),+ responses(+ (status = 200, body = GenericSuccessResponse),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn unassign_initiative_task_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ access: InitiativeAccessExtractor<EditAccessLevel, Eas, Auth>,+ Path(UnassignTaskParams { task_id, .. }): Path<UnassignTaskParams>,+) -> Result<Json<GenericSuccessResponse>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ state+ .service+ .unassign_task(access.entity_access_receipt, &task_id)+ .await?;+ Ok(Json(GenericSuccessResponse { success: true }))+}diff --git a/crates/initiative/src/inbound/axum_router/update.rs b/crates/initiative/src/inbound/axum_router/update.rsnew file mode 100644index 0000000000..9f5c1424c7--- /dev/null+++ b/crates/initiative/src/inbound/axum_router/update.rs@@ -0,0 +1,50 @@+//! Handler for updating an initiative.++use axum::{Json, extract::State};+use entity_access::domain::models::EditAccessLevel;+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::InitiativeAccessExtractor;+use macro_authorization::MacroAuthorizationService;+use model_error_response::ErrorResponse;++use super::{InitiativeIdParams, InitiativeRouterState};+use crate::domain::{+ models::{InitiativeDetail, InitiativeError, UpdateInitiativeRequest},+ ports::InitiativeService,+};++/// Update fields the caller can edit.+#[utoipa::path(+ patch,+ tag = "initiative",+ operation_id = "update_initiative",+ path = "/initiatives/{initiative_id}",+ params(InitiativeIdParams),+ request_body = UpdateInitiativeRequest,+ responses(+ (status = 200, body = InitiativeDetail),+ (status = 400, body = ErrorResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 409, body = ErrorResponse),+ (status = 422, description = "Name exceeds the maximum length", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn update_initiative_handler<S, Eas, Auth>(+ State(state): State<InitiativeRouterState<S, Eas, Auth>>,+ access: InitiativeAccessExtractor<EditAccessLevel, Eas, Auth>,+ Json(request): Json<UpdateInitiativeRequest>,+) -> Result<Json<InitiativeDetail>, InitiativeError>+where+ S: InitiativeService,+ Eas: EntityAccessService,+ Auth: MacroAuthorizationService,+{+ let detail = state+ .service+ .update(access.entity_access_receipt, request)+ .await?;+ Ok(Json(detail))+}