Skip to content

armgit / macro

Public Imported from GitHub
0

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

feat(initiatives): crates/initiative inbound axum router handlers middleware router tests (#6452)

Will Hutchinson1e24ee9f5661
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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))
+}