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 scaffold and domain layer models ports service (#6424)

Will Hutchinson4365b740714a
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 5d0cfcfcb5..ab4e01bd1b 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -4995,6 +4995,42 @@
"crates/system_properties",
"crates/workspace-hack"
],
+ "initiative": [
+ "crates/agent",
+ "crates/ai_toolset",
+ "crates/ai_usage",
+ "crates/attachment",
+ "crates/bot_id",
+ "crates/bot_token",
+ "crates/cowlike",
+ "crates/database_env_vars",
+ "crates/document_sub_type",
+ "crates/entity_access",
+ "crates/genai_telemetry",
+ "crates/harness_id",
+ "crates/harness_token",
+ "crates/initiative",
+ "crates/macro_auth",
+ "crates/macro_authorization",
+ "crates/macro_entrypoint",
+ "crates/macro_env",
+ "crates/macro_env_var",
+ "crates/macro_user_id",
+ "crates/macro_uuid",
+ "crates/model",
+ "crates/model-entity",
+ "crates/model-error-response",
+ "crates/model_file_type",
+ "crates/model_user",
+ "crates/models_bulk_upload",
+ "crates/models_entity_access_management",
+ "crates/models_pagination",
+ "crates/models_permissions",
+ "crates/non_empty",
+ "crates/prompt",
+ "crates/remote_env_var",
+ "crates/workspace-hack"
+ ],
"invite_email": [
"crates/ai_toolset",
"crates/bot_id",
diff --git a/Cargo.lock b/Cargo.lock
index 50fc4ef63b..ed71bdf469 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8710,6 +8710,31 @@ dependencies = [
"cfb",
]
+[[package]]
+name = "initiative"
+version = "0.1.0"
+dependencies = [
+ "axum",
+ "chrono",
+ "entity_access",
+ "macro_authorization",
+ "macro_user_id",
+ "mockall",
+ "model-error-response",
+ "models_permissions",
+ "rootcause",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "unicode-segmentation",
+ "utoipa",
+ "uuid",
+ "workspace-hack",
+]
+
[[package]]
name = "inout"
version = "0.1.4"
diff --git a/Cargo.toml b/Cargo.toml
index 1b322aa45f..9a6f537a8b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -53,6 +53,7 @@ members = [
"crates/harness_token",
"crates/harnesses",
"crates/import",
+ "crates/initiative",
"crates/item_filter_index",
"crates/integration_tests/local_e2e",
"crates/loops_client",
diff --git a/crates/initiative/Cargo.toml b/crates/initiative/Cargo.toml
new file mode 100644
index 0000000000..b634c10aa1
--- /dev/null
+++ b/crates/initiative/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+edition = "2024"
+name = "initiative"
+publish = false
+version = "0.1.0"
+
+[features]
+default = ["ports"]
+inbound = [
+ "dep:axum",
+ "dep:macro_authorization",
+ "dep:model-error-response",
+ "dep:utoipa",
+ "entity_access/inbound",
+ "ports",
+]
+outbound = ["ports"]
+ports = ["dep:entity_access", "dep:tracing"]
+postgres = ["dep:sqlx", "outbound"]
+
+[dependencies]
+axum = { workspace = true, optional = true }
+chrono = { workspace = true, features = ["serde"] }
+entity_access = { path = "../entity_access", optional = true, default-features = false, features = ["ports"] }
+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = ["axum"] }
+macro_user_id = { path = "../macro_user_id" }
+model-error-response = { path = "../model-error-response", optional = true }
+models_permissions = { path = "../models_permissions" }
+rootcause = { workspace = true }
+serde = { workspace = true }
+sqlx = { workspace = true, optional = true }
+thiserror = { workspace = true }
+tracing = { workspace = true, optional = true }
+unicode-segmentation = { workspace = true }
+utoipa = { workspace = true, optional = true }
+uuid = { workspace = true, features = ["serde", "v7"] }
+workspace-hack = { version = "0.1", path = "../workspace-hack" }
+mockall = { workspace = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
diff --git a/crates/initiative/fixtures/initiative_test_data.sql b/crates/initiative/fixtures/initiative_test_data.sql
new file mode 100644
index 0000000000..a2cc7abf99
--- /dev/null
+++ b/crates/initiative/fixtures/initiative_test_data.sql
@@ -0,0 +1 @@
+-- Test seed for the initiative repository.
diff --git a/crates/initiative/src/domain.rs b/crates/initiative/src/domain.rs
new file mode 100644
index 0000000000..bd7275fb48
--- /dev/null
+++ b/crates/initiative/src/domain.rs
@@ -0,0 +1,7 @@
+//! Domain layer for initiatives.
+
+pub mod models;
+#[cfg(feature = "ports")]
+pub mod ports;
+#[cfg(feature = "ports")]
+pub mod service;
diff --git a/crates/initiative/src/domain/models.rs b/crates/initiative/src/domain/models.rs
new file mode 100644
index 0000000000..93473ea210
--- /dev/null
+++ b/crates/initiative/src/domain/models.rs
@@ -0,0 +1,328 @@
+//! Domain models for initiatives.
+
+#[cfg(test)]
+mod test;
+
+use std::fmt;
+use std::str::FromStr;
+
+use chrono::{DateTime, Utc};
+use macro_user_id::user_id::MacroUserIdStr;
+use models_permissions::share_permission::access_level::AccessLevel;
+use models_permissions::share_permission::team_share::AuthorizedTeamShareCommand;
+use models_permissions::share_permission::{SharePermissionV2, UpdateSharePermissionRequestV2};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Maximum initiative name length, counted in Unicode grapheme clusters.
+pub const MAX_INITIATIVE_NAME_GRAPHEMES: usize = 100;
+
+/// Maximum initiative description length, counted in Unicode grapheme clusters.
+pub const MAX_INITIATIVE_DESCRIPTION_GRAPHEMES: usize = 2_000;
+
+/// Maximum number of tasks accepted in one assign call.
+pub const MAX_TASKS_PER_ASSIGN: usize = 100;
+
+/// Opaque identifier for an initiative. Minted as UUIDv7 in application code.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(transparent)]
+pub struct InitiativeId(Uuid);
+
+impl InitiativeId {
+ /// Mint a new UUIDv7 identifier.
+ pub fn generate() -> Self {
+ Self(Uuid::now_v7())
+ }
+
+ /// Wrap an already-persisted id.
+ pub fn from_uuid(id: Uuid) -> Self {
+ Self(id)
+ }
+
+ /// The inner UUID.
+ pub fn as_uuid(&self) -> Uuid {
+ self.0
+ }
+}
+
+impl fmt::Display for InitiativeId {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.0)
+ }
+}
+
+impl FromStr for InitiativeId {
+ type Err = uuid::Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ Ok(Self(Uuid::parse_str(s)?))
+ }
+}
+
+/// Persisted initiative row without members, tasks, or share state.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct Initiative {
+ /// Opaque identifier.
+ pub id: InitiativeId,
+ /// Display name.
+ pub name: String,
+ /// Optional description.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Owner of the initiative.
+ pub owner_id: MacroUserIdStr<'static>,
+ /// When the initiative was created.
+ pub created_at: DateTime<Utc>,
+ /// When the initiative was last updated.
+ pub updated_at: DateTime<Utc>,
+}
+
+/// Minimal initiative identity used by access checks and internal lookups.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct InitiativeBasic {
+ /// Opaque identifier.
+ pub id: InitiativeId,
+ /// Display name.
+ pub name: String,
+ /// Owner of the initiative.
+ pub owner_id: MacroUserIdStr<'static>,
+}
+
+/// List-row view of an initiative.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct InitiativeSummary {
+ /// Opaque identifier.
+ pub id: InitiativeId,
+ /// Display name.
+ pub name: String,
+ /// Optional description.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// When the initiative was last updated.
+ pub updated_at: DateTime<Utc>,
+}
+
+/// Full initiative returned to a caller, including members, tasks, and share state.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct InitiativeDetail {
+ /// Opaque identifier.
+ pub id: InitiativeId,
+ /// Display name.
+ pub name: String,
+ /// Optional description.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Owner of the initiative.
+ pub owner_id: MacroUserIdStr<'static>,
+ /// Member user ids. The owner is never stored here.
+ pub member_ids: Vec<MacroUserIdStr<'static>>,
+ /// Task ids currently assigned to the initiative.
+ pub task_ids: Vec<String>,
+ /// Current share permission.
+ pub share_permission: SharePermissionV2,
+ /// Caller's access level on this initiative.
+ pub user_access_level: AccessLevel,
+ /// When the initiative was created.
+ pub created_at: DateTime<Utc>,
+ /// When the initiative was last updated.
+ pub updated_at: DateTime<Utc>,
+}
+
+/// Create-initiative HTTP body.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct CreateInitiativeRequest {
+ /// Display name.
+ pub name: String,
+ /// Optional description.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Optional member user ids. Invalid ids fail at the service boundary.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub member_ids: Option<Vec<String>>,
+ /// When true, share with the owner's team at create time.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub share_with_team: Option<bool>,
+}
+
+/// Update-initiative HTTP body. Absent fields are left unchanged. `member_ids`
+/// present is a full replace.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateInitiativeRequest {
+ /// Replacement name.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub name: Option<String>,
+ /// Replacement description. `Some("")` clears it after trim.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+ /// Full replacement member list when present.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub member_ids: Option<Vec<String>>,
+ /// Share permission patch. Only the owner may send this field.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub share_permission: Option<UpdateSharePermissionRequestV2>,
+}
+
+/// Assign-tasks HTTP body.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct AssignTasksRequest {
+ /// Task ids to assign, in request order.
+ pub task_ids: Vec<String>,
+}
+
+/// Per-task outcome of an assign call.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct AssignTasksResult {
+ /// Task id this outcome describes.
+ pub task_id: String,
+ /// What happened to the task.
+ pub status: AssignTaskStatus,
+}
+
+/// Assign-tasks HTTP response.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct AssignTasksResponse {
+ /// Outcomes in request order after dedupe.
+ pub results: Vec<AssignTasksResult>,
+}
+
+/// Status written onto one assign result.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub enum AssignTaskStatus {
+ /// Newly assigned to this initiative.
+ Assigned,
+ /// Moved here from another initiative.
+ Moved,
+ /// The id exists but is not a task.
+ NotATask,
+ /// The id does not exist.
+ NotFound,
+ /// The caller cannot assign this task.
+ SkippedNoPermission,
+}
+
+/// Accessible-initiative list.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "inbound", derive(utoipa::ToSchema))]
+#[serde(rename_all = "camelCase")]
+pub struct InitiativeList {
+ /// Initiatives the caller can view.
+ pub initiatives: Vec<InitiativeSummary>,
+}
+
+/// One task in an assign-tasks service call, after inbound access filtering.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TaskAssignment {
+ /// Inbound confirmed the caller can assign this task.
+ Candidate {
+ /// Task id.
+ task_id: String,
+ },
+ /// Inbound could not find this task.
+ NotFound {
+ /// Task id.
+ task_id: String,
+ },
+ /// Inbound found the task but the caller cannot assign it.
+ SkippedNoPermission {
+ /// Task id.
+ task_id: String,
+ },
+}
+
+impl TaskAssignment {
+ /// Task id this assignment refers to.
+ pub fn task_id(&self) -> &str {
+ match self {
+ Self::Candidate { task_id }
+ | Self::NotFound { task_id }
+ | Self::SkippedNoPermission { task_id } => task_id,
+ }
+ }
+}
+
+/// Arguments for creating an initiative row. No serde: repository-only.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CreateInitiativeRepoArgs {
+ /// App-generated identifier.
+ pub id: InitiativeId,
+ /// Owner / creator.
+ pub owner_id: MacroUserIdStr<'static>,
+ /// Validated name.
+ pub name: String,
+ /// Validated description.
+ pub description: Option<String>,
+ /// Member ids with the owner removed and duplicates dropped.
+ pub member_ids: Vec<MacroUserIdStr<'static>>,
+}
+
+/// Arguments for updating an initiative row. No serde: repository-only.
+#[derive(Debug, Clone)]
+pub struct UpdateInitiativeRepoArgs {
+ /// Initiative to update.
+ pub id: InitiativeId,
+ /// Replacement name when present.
+ pub name: Option<String>,
+ /// Replacement description when present. `Some(None)` clears it.
+ pub description: Option<Option<String>>,
+ /// Members to add when `member_ids` was present on the request.
+ pub member_ids_added: Vec<MacroUserIdStr<'static>>,
+ /// Members to remove when `member_ids` was present on the request.
+ pub member_ids_removed: Vec<MacroUserIdStr<'static>>,
+ /// Share permission patch when the owner sent one.
+ pub share_permission: Option<UpdateSharePermissionRequestV2>,
+ /// Authorized team-share write, if any.
+ pub team_share: Option<AuthorizedTeamShareCommand>,
+}
+
+/// Errors returned by the initiative service.
+#[derive(Debug, thiserror::Error)]
+pub enum InitiativeError {
+ /// The initiative does not exist.
+ #[error("initiative not found")]
+ NotFound,
+ /// The caller cannot perform this action.
+ #[error("unauthorized")]
+ Unauthorized,
+ /// The request was invalid.
+ #[error("{0}")]
+ BadRequest(String),
+ /// The write conflicted with current state.
+ #[error("{0}")]
+ Conflict(String),
+ /// The name exceeds the grapheme limit.
+ #[error("name too long")]
+ NameTooLong {
+ /// Maximum allowed name length, in grapheme clusters.
+ max: usize,
+ },
+ /// Any other internal error.
+ #[error("internal initiative error: {0:?}")]
+ Internal(rootcause::Report),
+}
+
+impl From<rootcause::Report> for InitiativeError {
+ fn from(report: rootcause::Report) -> Self {
+ InitiativeError::Internal(report)
+ }
+}
diff --git a/crates/initiative/src/domain/models/test.rs b/crates/initiative/src/domain/models/test.rs
new file mode 100644
index 0000000000..afcd2f8944
--- /dev/null
+++ b/crates/initiative/src/domain/models/test.rs
@@ -0,0 +1,70 @@
+use super::*;
+
+#[test]
+fn initiative_id_round_trips_uuid_strings() {
+ let id = InitiativeId::generate();
+ let parsed = InitiativeId::from_str(&id.to_string()).expect("uuid string");
+ assert_eq!(parsed, id);
+ assert_eq!(InitiativeId::from_uuid(id.as_uuid()), id);
+}
+
+#[test]
+fn wire_types_serialize_camel_case() {
+ let json = serde_json::to_value(AssignTasksResponse {
+ results: vec![AssignTasksResult {
+ task_id: "task-1".to_string(),
+ status: AssignTaskStatus::NotATask,
+ }],
+ })
+ .expect("json");
+ assert_eq!(
+ json,
+ serde_json::json!({
+ "results": [{ "taskId": "task-1", "status": "notATask" }]
+ })
+ );
+
+ let skipped = serde_json::to_value(AssignTaskStatus::SkippedNoPermission).expect("json");
+ assert_eq!(skipped, serde_json::json!("skippedNoPermission"));
+}
+
+#[test]
+fn create_request_deserializes_camel_case() {
+ let request: CreateInitiativeRequest = serde_json::from_value(serde_json::json!({
+ "name": "Launch",
+ "memberIds": ["macro|[email protected]"],
+ "shareWithTeam": true
+ }))
+ .expect("request");
+ assert_eq!(request.name, "Launch");
+ assert_eq!(
+ request.member_ids.as_deref(),
+ Some(["macro|[email protected]".to_string()].as_slice())
+ );
+ assert_eq!(request.share_with_team, Some(true));
+}
+
+#[test]
+fn task_assignment_exposes_task_id() {
+ assert_eq!(
+ TaskAssignment::Candidate {
+ task_id: "t1".into()
+ }
+ .task_id(),
+ "t1"
+ );
+ assert_eq!(
+ TaskAssignment::NotFound {
+ task_id: "t2".into()
+ }
+ .task_id(),
+ "t2"
+ );
+ assert_eq!(
+ TaskAssignment::SkippedNoPermission {
+ task_id: "t3".into()
+ }
+ .task_id(),
+ "t3"
+ );
+}
diff --git a/crates/initiative/src/domain/ports.rs b/crates/initiative/src/domain/ports.rs
new file mode 100644
index 0000000000..b84480e4f0
--- /dev/null
+++ b/crates/initiative/src/domain/ports.rs
@@ -0,0 +1,137 @@
+//! Ports (trait contracts) for the initiative domain.
+
+use entity_access::domain::models::{
+ EditAccessLevel, EntityAccessReceipt, OwnerAccessLevel, ViewAccessLevel,
+};
+use macro_user_id::user_id::MacroUserIdStr;
+use models_permissions::share_permission::team_share::{TeamShareCreation, TeamShareFacts};
+use models_permissions::share_permission::{SharePermissionV2, TeamLinkShareDefault};
+
+use crate::domain::models::{
+ AssignTasksResponse, AssignTasksResult, CreateInitiativeRepoArgs, CreateInitiativeRequest,
+ InitiativeBasic, InitiativeDetail, InitiativeError, InitiativeId, InitiativeList,
+ TaskAssignment, UpdateInitiativeRepoArgs, UpdateInitiativeRequest,
+};
+
+/// Outbound persistence port for initiatives.
+#[cfg_attr(test, mockall::automock(type Err = InitiativeError;))]
+pub trait InitiativeRepo: Send + Sync + 'static {
+ /// The error type returned by repository operations.
+ type Err: Into<InitiativeError> + Send + std::fmt::Debug;
+
+ /// Persist a new initiative, its members, and initial share state.
+ fn create(
+ &self,
+ args: CreateInitiativeRepoArgs,
+ share_permission: SharePermissionV2,
+ team_share: TeamShareCreation,
+ ) -> impl Future<Output = Result<InitiativeDetail, Self::Err>> + Send;
+
+ /// Load the identity row used by access checks.
+ fn get_basic(
+ &self,
+ id: InitiativeId,
+ ) -> impl Future<Output = Result<Option<InitiativeBasic>, Self::Err>> + Send;
+
+ /// Load the full initiative, including members, tasks, and share state.
+ fn get_detail(
+ &self,
+ id: InitiativeId,
+ ) -> impl Future<Output = Result<Option<InitiativeDetail>, Self::Err>> + Send;
+
+ /// List initiatives the user can view.
+ fn list_accessible(
+ &self,
+ user_id: &MacroUserIdStr<'static>,
+ ) -> impl Future<Output = Result<InitiativeList, Self::Err>> + Send;
+
+ /// Apply an update, including member add/remove sets and optional team share.
+ fn update(
+ &self,
+ args: UpdateInitiativeRepoArgs,
+ ) -> impl Future<Output = Result<InitiativeDetail, Self::Err>> + Send;
+
+ /// Load canonical team-share facts for an initiative.
+ fn get_team_share_facts(
+ &self,
+ id: InitiativeId,
+ ) -> impl Future<Output = Result<TeamShareFacts, Self::Err>> + Send;
+
+ /// Load the owner's team default link-share preference, if any.
+ fn get_team_default_link_share(
+ &self,
+ user_id: &MacroUserIdStr<'static>,
+ ) -> impl Future<Output = Result<Option<TeamLinkShareDefault>, Self::Err>> + Send;
+
+ /// Assign the accepted task ids. Returns one outcome per submitted id.
+ fn assign_tasks(
+ &self,
+ id: InitiativeId,
+ task_ids: Vec<String>,
+ ) -> impl Future<Output = Result<Vec<AssignTasksResult>, Self::Err>> + Send;
+
+ /// Remove one task from the initiative.
+ fn unassign_task(
+ &self,
+ id: InitiativeId,
+ task_id: &str,
+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;
+
+ /// Delete the initiative and clean up related rows in one transaction.
+ fn delete(&self, id: InitiativeId) -> impl Future<Output = Result<(), Self::Err>> + Send;
+}
+
+/// Inbound service port: the initiative API used by drivers (HTTP).
+pub trait InitiativeService: Send + Sync + 'static {
+ /// Create an initiative owned by `user_id`.
+ fn create(
+ &self,
+ user_id: &MacroUserIdStr<'_>,
+ request: CreateInitiativeRequest,
+ ) -> impl Future<Output = Result<InitiativeDetail, InitiativeError>> + Send;
+
+ /// Load identity without an access receipt. For internal callers only.
+ fn internal_get_basic(
+ &self,
+ id: InitiativeId,
+ ) -> impl Future<Output = Result<InitiativeBasic, InitiativeError>> + Send;
+
+ /// Load the full initiative the receipt already authorized for view.
+ fn get(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> impl Future<Output = Result<InitiativeDetail, InitiativeError>> + Send;
+
+ /// List initiatives the user can view.
+ fn list(
+ &self,
+ user_id: &MacroUserIdStr<'_>,
+ ) -> impl Future<Output = Result<InitiativeList, InitiativeError>> + Send;
+
+ /// Update fields the receipt already authorized for edit.
+ fn update(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ request: UpdateInitiativeRequest,
+ ) -> impl Future<Output = Result<InitiativeDetail, InitiativeError>> + Send;
+
+ /// Assign tasks the receipt already authorized for edit.
+ fn assign_tasks(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ assignments: Vec<TaskAssignment>,
+ ) -> impl Future<Output = Result<AssignTasksResponse, InitiativeError>> + Send;
+
+ /// Unassign one task the receipt already authorized for edit.
+ fn unassign_task(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ task_id: &str,
+ ) -> impl Future<Output = Result<(), InitiativeError>> + Send;
+
+ /// Delete the initiative the receipt already authorized as owner.
+ fn delete(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> impl Future<Output = Result<(), InitiativeError>> + Send;
+}
diff --git a/crates/initiative/src/domain/service.rs b/crates/initiative/src/domain/service.rs
new file mode 100644
index 0000000000..fc73218ed3
--- /dev/null
+++ b/crates/initiative/src/domain/service.rs
@@ -0,0 +1,399 @@
+//! Initiative service implementation.
+
+#[cfg(test)]
+mod test;
+
+use std::collections::{HashMap, HashSet};
+use std::str::FromStr;
+
+use entity_access::domain::models::{
+ AccessLevel, EditAccessLevel, EntityAccessReceipt, EntityPermission, EntityType,
+ OwnerAccessLevel, ViewAccessLevel,
+};
+use macro_user_id::cowlike::CowLike;
+use macro_user_id::user_id::MacroUserIdStr;
+use models_permissions::share_permission::SharePermissionV2;
+use models_permissions::share_permission::team_share::{
+ AuthorizedTeamShareCommand, TeamShareCreation, TeamShareLevel, TeamSharePolicyError,
+ TeamShareRequest, authorize_team_share,
+};
+use unicode_segmentation::UnicodeSegmentation;
+
+use crate::domain::models::{
+ AssignTaskStatus, AssignTasksResponse, AssignTasksResult, CreateInitiativeRepoArgs,
+ CreateInitiativeRequest, InitiativeBasic, InitiativeDetail, InitiativeError, InitiativeId,
+ InitiativeList, MAX_INITIATIVE_DESCRIPTION_GRAPHEMES, MAX_INITIATIVE_NAME_GRAPHEMES,
+ MAX_TASKS_PER_ASSIGN, TaskAssignment, UpdateInitiativeRepoArgs, UpdateInitiativeRequest,
+};
+use crate::domain::ports::{InitiativeRepo, InitiativeService};
+
+/// Concrete initiative service backed by an [`InitiativeRepo`].
+#[derive(Debug, Clone)]
+pub struct InitiativeServiceImpl<R> {
+ repo: R,
+}
+
+impl<R> InitiativeServiceImpl<R>
+where
+ R: InitiativeRepo,
+{
+ /// Create an initiative service backed by the provided repository.
+ pub fn new(repo: R) -> Self {
+ Self { repo }
+ }
+
+ async fn authorize_initiative_team_share(
+ &self,
+ receipt: &EntityAccessReceipt<EditAccessLevel>,
+ request: TeamShareRequest,
+ ) -> Result<Option<AuthorizedTeamShareCommand>, InitiativeError> {
+ if request == TeamShareRequest::default() {
+ return Ok(None);
+ }
+ let id = initiative_id_from_receipt(receipt)?;
+ let facts = self
+ .repo
+ .get_team_share_facts(id)
+ .await
+ .map_err(Into::into)?;
+ authorize_team_share(
+ receipt.acting_user_id(),
+ &facts,
+ request,
+ TeamShareLevel::Edit,
+ )
+ .map_err(|error| match error {
+ TeamSharePolicyError::MissingActor | TeamSharePolicyError::NotOwner => {
+ InitiativeError::Unauthorized
+ }
+ TeamSharePolicyError::InvalidRevision => InitiativeError::Conflict(error.to_string()),
+ _ => InitiativeError::BadRequest(error.to_string()),
+ })
+ }
+}
+
+impl<R> InitiativeService for InitiativeServiceImpl<R>
+where
+ R: InitiativeRepo,
+ R::Err: Into<InitiativeError>,
+{
+ #[tracing::instrument(err, skip_all)]
+ async fn create(
+ &self,
+ user_id: &MacroUserIdStr<'_>,
+ request: CreateInitiativeRequest,
+ ) -> Result<InitiativeDetail, InitiativeError> {
+ let name = normalize_name(&request.name)?;
+ let description = normalize_description(request.description)?;
+ let owner_id = user_id.clone().into_owned();
+ let member_ids = parse_member_ids(request.member_ids.unwrap_or_default(), &owner_id)?;
+ let team_default = self
+ .repo
+ .get_team_default_link_share(&owner_id)
+ .await
+ .map_err(Into::into)?;
+ let share_permission = SharePermissionV2::new_initiative_share_permission(team_default);
+ let team_share = if request.share_with_team == Some(true) {
+ TeamShareCreation::Initiative
+ } else {
+ TeamShareCreation::Unshared
+ };
+ self.repo
+ .create(
+ CreateInitiativeRepoArgs {
+ id: InitiativeId::generate(),
+ owner_id,
+ name,
+ description,
+ member_ids,
+ },
+ share_permission,
+ team_share,
+ )
+ .await
+ .map_err(Into::into)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn internal_get_basic(
+ &self,
+ id: InitiativeId,
+ ) -> Result<InitiativeBasic, InitiativeError> {
+ self.repo
+ .get_basic(id)
+ .await
+ .map_err(Into::into)?
+ .ok_or(InitiativeError::NotFound)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn get(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> Result<InitiativeDetail, InitiativeError> {
+ let id = initiative_id_from_receipt(&receipt)?;
+ self.repo
+ .get_detail(id)
+ .await
+ .map_err(Into::into)?
+ .ok_or(InitiativeError::NotFound)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn list(&self, user_id: &MacroUserIdStr<'_>) -> Result<InitiativeList, InitiativeError> {
+ let user_id = user_id.clone().into_owned();
+ self.repo
+ .list_accessible(&user_id)
+ .await
+ .map_err(Into::into)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn update(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ request: UpdateInitiativeRequest,
+ ) -> Result<InitiativeDetail, InitiativeError> {
+ if request.share_permission.is_some() && !receipt_is_owner(&receipt) {
+ return Err(InitiativeError::Unauthorized);
+ }
+
+ let name = request.name.as_deref().map(normalize_name).transpose()?;
+ let description = match request.description {
+ None => None,
+ Some(value) => Some(normalize_description(Some(value))?),
+ };
+
+ let id = initiative_id_from_receipt(&receipt)?;
+ let (member_ids_added, member_ids_removed) = if let Some(member_ids) = request.member_ids {
+ let current = self
+ .repo
+ .get_detail(id)
+ .await
+ .map_err(Into::into)?
+ .ok_or(InitiativeError::NotFound)?;
+ let requested = parse_member_ids(member_ids, &current.owner_id)?;
+ member_diff(&current.member_ids, &requested)
+ } else {
+ (Vec::new(), Vec::new())
+ };
+
+ let team_share = if let Some(share_permission) = request.share_permission.as_ref() {
+ self.authorize_initiative_team_share(
+ &receipt,
+ TeamShareRequest {
+ access_level: share_permission.team_share_access_level,
+ legacy_enabled: None,
+ },
+ )
+ .await?
+ } else {
+ None
+ };
+
+ self.repo
+ .update(UpdateInitiativeRepoArgs {
+ id,
+ name,
+ description,
+ member_ids_added,
+ member_ids_removed,
+ share_permission: request.share_permission,
+ team_share,
+ })
+ .await
+ .map_err(Into::into)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn assign_tasks(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ assignments: Vec<TaskAssignment>,
+ ) -> Result<AssignTasksResponse, InitiativeError> {
+ if receipt.entity().entity_type != EntityType::Initiative {
+ return Err(InitiativeError::BadRequest(
+ "assign_tasks requires an initiative access receipt".to_string(),
+ ));
+ }
+
+ let assignments = dedupe_assignments(assignments);
+ if assignments.len() > MAX_TASKS_PER_ASSIGN {
+ return Err(InitiativeError::BadRequest(format!(
+ "cannot assign more than {MAX_TASKS_PER_ASSIGN} tasks at once"
+ )));
+ }
+
+ let id = initiative_id_from_receipt(&receipt)?;
+ let candidate_ids: Vec<String> = assignments
+ .iter()
+ .filter_map(|assignment| match assignment {
+ TaskAssignment::Candidate { task_id } => Some(task_id.clone()),
+ TaskAssignment::NotFound { .. } | TaskAssignment::SkippedNoPermission { .. } => {
+ None
+ }
+ })
+ .collect();
+
+ let repo_results = if candidate_ids.is_empty() {
+ Vec::new()
+ } else {
+ self.repo
+ .assign_tasks(id, candidate_ids)
+ .await
+ .map_err(Into::into)?
+ };
+
+ Ok(AssignTasksResponse {
+ results: merge_assign_results(&assignments, repo_results),
+ })
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn unassign_task(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ task_id: &str,
+ ) -> Result<(), InitiativeError> {
+ let id = initiative_id_from_receipt(&receipt)?;
+ self.repo
+ .unassign_task(id, task_id)
+ .await
+ .map_err(Into::into)
+ }
+
+ #[tracing::instrument(err, skip_all)]
+ async fn delete(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> Result<(), InitiativeError> {
+ let id = initiative_id_from_receipt(&receipt)?;
+ self.repo.delete(id).await.map_err(Into::into)
+ }
+}
+
+fn receipt_is_owner<T: entity_access::domain::models::RequiredPermission>(
+ receipt: &EntityAccessReceipt<T>,
+) -> bool {
+ matches!(
+ receipt.entity_permission(),
+ EntityPermission::AccessLevel {
+ access_level: AccessLevel::Owner,
+ }
+ )
+}
+
+fn initiative_id_from_receipt<T: entity_access::domain::models::RequiredPermission>(
+ receipt: &EntityAccessReceipt<T>,
+) -> Result<InitiativeId, InitiativeError> {
+ InitiativeId::from_str(&receipt.entity().entity_id)
+ .map_err(|_| InitiativeError::BadRequest("invalid initiative id".to_string()))
+}
+
+fn normalize_name(name: &str) -> Result<String, InitiativeError> {
+ let name = name.trim();
+ if name.is_empty() {
+ return Err(InitiativeError::BadRequest(
+ "initiative name must not be empty".to_string(),
+ ));
+ }
+ if name.graphemes(true).count() > MAX_INITIATIVE_NAME_GRAPHEMES {
+ return Err(InitiativeError::NameTooLong {
+ max: MAX_INITIATIVE_NAME_GRAPHEMES,
+ });
+ }
+ Ok(name.to_string())
+}
+
+fn normalize_description(description: Option<String>) -> Result<Option<String>, InitiativeError> {
+ let Some(description) = description else {
+ return Ok(None);
+ };
+ let description = description.trim();
+ if description.is_empty() {
+ return Ok(None);
+ }
+ if description.graphemes(true).count() > MAX_INITIATIVE_DESCRIPTION_GRAPHEMES {
+ return Err(InitiativeError::BadRequest(format!(
+ "description must be at most {MAX_INITIATIVE_DESCRIPTION_GRAPHEMES} graphemes"
+ )));
+ }
+ Ok(Some(description.to_string()))
+}
+
+fn parse_member_ids(
+ member_ids: Vec<String>,
+ owner: &MacroUserIdStr<'_>,
+) -> Result<Vec<MacroUserIdStr<'static>>, InitiativeError> {
+ let mut seen = HashSet::new();
+ let mut parsed = Vec::new();
+ for raw in member_ids {
+ let member = MacroUserIdStr::parse_from_str(&raw)
+ .map_err(|error| InitiativeError::BadRequest(error.to_string()))?
+ .into_owned();
+ if member.as_ref() == owner.as_ref() {
+ continue;
+ }
+ if seen.insert(member.to_string()) {
+ parsed.push(member);
+ }
+ }
+ Ok(parsed)
+}
+
+fn member_diff(
+ current: &[MacroUserIdStr<'static>],
+ requested: &[MacroUserIdStr<'static>],
+) -> (Vec<MacroUserIdStr<'static>>, Vec<MacroUserIdStr<'static>>) {
+ let current_set: HashSet<&str> = current.iter().map(|id| id.as_ref()).collect();
+ let requested_set: HashSet<&str> = requested.iter().map(|id| id.as_ref()).collect();
+ let added = requested
+ .iter()
+ .filter(|id| !current_set.contains(id.as_ref()))
+ .cloned()
+ .collect();
+ let removed = current
+ .iter()
+ .filter(|id| !requested_set.contains(id.as_ref()))
+ .cloned()
+ .collect();
+ (added, removed)
+}
+
+fn dedupe_assignments(assignments: Vec<TaskAssignment>) -> Vec<TaskAssignment> {
+ let mut seen = HashSet::new();
+ assignments
+ .into_iter()
+ .filter(|assignment| seen.insert(assignment.task_id().to_string()))
+ .collect()
+}
+
+fn merge_assign_results(
+ assignments: &[TaskAssignment],
+ repo_results: Vec<AssignTasksResult>,
+) -> Vec<AssignTasksResult> {
+ let repo_by_id: HashMap<String, AssignTaskStatus> = repo_results
+ .into_iter()
+ .map(|result| (result.task_id, result.status))
+ .collect();
+ assignments
+ .iter()
+ .map(|assignment| match assignment {
+ TaskAssignment::Candidate { task_id } => AssignTasksResult {
+ task_id: task_id.clone(),
+ status: repo_by_id
+ .get(task_id)
+ .copied()
+ .unwrap_or(AssignTaskStatus::NotFound),
+ },
+ TaskAssignment::NotFound { task_id } => AssignTasksResult {
+ task_id: task_id.clone(),
+ status: AssignTaskStatus::NotFound,
+ },
+ TaskAssignment::SkippedNoPermission { task_id } => AssignTasksResult {
+ task_id: task_id.clone(),
+ status: AssignTaskStatus::SkippedNoPermission,
+ },
+ })
+ .collect()
+}
diff --git a/crates/initiative/src/domain/service/test.rs b/crates/initiative/src/domain/service/test.rs
new file mode 100644
index 0000000000..640b651582
--- /dev/null
+++ b/crates/initiative/src/domain/service/test.rs
@@ -0,0 +1,444 @@
+use chrono::{TimeZone, Utc};
+use entity_access::domain::models::{
+ AccessLevel, EditAccessLevel, Entity, EntityAccessReceipt, EntityPermission, EntityType,
+ OwnerAccessLevel, ViewAccessLevel,
+};
+use macro_user_id::cowlike::CowLike;
+use macro_user_id::user_id::MacroUserIdStr;
+use models_permissions::share_permission::access_level::AccessLevel as ShareAccessLevel;
+use models_permissions::share_permission::team_share::{TeamShareCreation, TeamShareFacts};
+use models_permissions::share_permission::{SharePermissionV2, UpdateSharePermissionRequestV2};
+
+use super::InitiativeServiceImpl;
+use crate::domain::models::{
+ AssignTaskStatus, AssignTasksResult, CreateInitiativeRequest, InitiativeBasic,
+ InitiativeDetail, InitiativeError, InitiativeId, InitiativeList, InitiativeSummary,
+ MAX_INITIATIVE_DESCRIPTION_GRAPHEMES, MAX_INITIATIVE_NAME_GRAPHEMES, MAX_TASKS_PER_ASSIGN,
+ TaskAssignment, UpdateInitiativeRequest,
+};
+use crate::domain::ports::{InitiativeService, MockInitiativeRepo};
+
+const OWNER: &str = "macro|[email protected]";
+const MEMBER: &str = "macro|[email protected]";
+const OTHER: &str = "macro|[email protected]";
+
+fn user(id: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::parse_from_str(id)
+ .expect("valid user id")
+ .into_owned()
+}
+
+fn now() -> chrono::DateTime<Utc> {
+ Utc.with_ymd_and_hms(2026, 9, 15, 12, 0, 0)
+ .single()
+ .expect("unambiguous instant")
+}
+
+fn initiative_id() -> InitiativeId {
+ InitiativeId::from_uuid(uuid::Uuid::from_u128(1))
+}
+
+fn share_permission() -> SharePermissionV2 {
+ SharePermissionV2::new_initiative_share_permission(None)
+}
+
+fn detail(member_ids: Vec<MacroUserIdStr<'static>>) -> InitiativeDetail {
+ InitiativeDetail {
+ id: initiative_id(),
+ name: "Launch".to_string(),
+ description: None,
+ owner_id: user(OWNER),
+ member_ids,
+ task_ids: Vec::new(),
+ share_permission: share_permission(),
+ user_access_level: ShareAccessLevel::Edit,
+ created_at: now(),
+ updated_at: now(),
+ }
+}
+
+fn receipt<T: entity_access::domain::models::RequiredPermission>(
+ user_id: &str,
+ entity_type: EntityType,
+ access_level: AccessLevel,
+) -> EntityAccessReceipt<T> {
+ EntityAccessReceipt::try_new_authenticated_user(
+ user(user_id),
+ Entity {
+ entity_id: initiative_id().to_string(),
+ entity_type,
+ },
+ EntityPermission::AccessLevel { access_level },
+ )
+ .expect("permission satisfies the receipt")
+}
+
+fn edit_receipt() -> EntityAccessReceipt<EditAccessLevel> {
+ receipt(OWNER, EntityType::Initiative, AccessLevel::Edit)
+}
+
+fn owner_edit_receipt() -> EntityAccessReceipt<EditAccessLevel> {
+ receipt(OWNER, EntityType::Initiative, AccessLevel::Owner)
+}
+
+fn view_receipt() -> EntityAccessReceipt<ViewAccessLevel> {
+ receipt(OWNER, EntityType::Initiative, AccessLevel::View)
+}
+
+fn owner_receipt() -> EntityAccessReceipt<OwnerAccessLevel> {
+ receipt(OWNER, EntityType::Initiative, AccessLevel::Owner)
+}
+
+fn service(repo: MockInitiativeRepo) -> InitiativeServiceImpl<MockInitiativeRepo> {
+ InitiativeServiceImpl::new(repo)
+}
+
+fn share_update() -> UpdateSharePermissionRequestV2 {
+ UpdateSharePermissionRequestV2 {
+ link_share: None,
+ link_share_access_level: None,
+ team_share_access_level: Some(Some(ShareAccessLevel::Edit)),
+ channel_share_permissions: None,
+ }
+}
+
+fn team_facts() -> TeamShareFacts {
+ TeamShareFacts {
+ entity: EntityType::Initiative.with_entity_string(initiative_id().to_string()),
+ owner: user(OWNER),
+ owner_team_id: Some(uuid::Uuid::from_u128(7)),
+ current: None,
+ revision: 0,
+ }
+}
+
+#[tokio::test]
+async fn create_rejects_empty_and_too_long_names() {
+ let repo = MockInitiativeRepo::new();
+ let svc = service(repo);
+ let empty = svc
+ .create(
+ &user(OWNER),
+ CreateInitiativeRequest {
+ name: " ".into(),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(empty, Err(InitiativeError::BadRequest(_))));
+
+ let too_long = svc
+ .create(
+ &user(OWNER),
+ CreateInitiativeRequest {
+ name: "🎉".repeat(MAX_INITIATIVE_NAME_GRAPHEMES + 1),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(
+ too_long,
+ Err(InitiativeError::NameTooLong {
+ max: MAX_INITIATIVE_NAME_GRAPHEMES
+ })
+ ));
+}
+
+#[tokio::test]
+async fn create_rejects_too_long_description() {
+ let repo = MockInitiativeRepo::new();
+ let result = service(repo)
+ .create(
+ &user(OWNER),
+ CreateInitiativeRequest {
+ name: "Launch".into(),
+ description: Some("🎉".repeat(MAX_INITIATIVE_DESCRIPTION_GRAPHEMES + 1)),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(result, Err(InitiativeError::BadRequest(_))));
+}
+
+#[tokio::test]
+async fn create_drops_owner_from_members_and_shares_with_team() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_team_default_link_share()
+ .return_once(|_| Box::pin(async { Ok(None) }));
+ repo.expect_create()
+ .withf(|args, _, team_share| {
+ *team_share == TeamShareCreation::Initiative
+ && args.member_ids == vec![user(MEMBER)]
+ && args.owner_id == user(OWNER)
+ })
+ .return_once(|_, _, _| Box::pin(async { Ok(detail(vec![user(MEMBER)])) }));
+
+ let created = service(repo)
+ .create(
+ &user(OWNER),
+ CreateInitiativeRequest {
+ name: " Launch ".into(),
+ member_ids: Some(vec![OWNER.into(), MEMBER.into(), MEMBER.into()]),
+ share_with_team: Some(true),
+ ..Default::default()
+ },
+ )
+ .await
+ .expect("created");
+ assert_eq!(created.member_ids, vec![user(MEMBER)]);
+}
+
+#[tokio::test]
+async fn create_rejects_bad_member_id() {
+ let repo = MockInitiativeRepo::new();
+ let result = service(repo)
+ .create(
+ &user(OWNER),
+ CreateInitiativeRequest {
+ name: "Launch".into(),
+ member_ids: Some(vec!["not-a-user".into()]),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(result, Err(InitiativeError::BadRequest(_))));
+}
+
+#[tokio::test]
+async fn edit_receipt_cannot_change_share_permission() {
+ let repo = MockInitiativeRepo::new();
+ let result = service(repo)
+ .update(
+ edit_receipt(),
+ UpdateInitiativeRequest {
+ share_permission: Some(share_update()),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(result, Err(InitiativeError::Unauthorized)));
+}
+
+#[tokio::test]
+async fn edit_receipt_renames_and_replaces_members() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_detail()
+ .return_once(|_| Box::pin(async { Ok(Some(detail(vec![user(MEMBER)]))) }));
+ repo.expect_update()
+ .withf(|args| {
+ args.name.as_deref() == Some("Renamed")
+ && args.member_ids_added == vec![user(OTHER)]
+ && args.member_ids_removed == vec![user(MEMBER)]
+ })
+ .return_once(|args| Box::pin(async move { Ok(detail(args.member_ids_added.clone())) }));
+
+ let updated = service(repo)
+ .update(
+ edit_receipt(),
+ UpdateInitiativeRequest {
+ name: Some("Renamed".into()),
+ member_ids: Some(vec![OTHER.into()]),
+ ..Default::default()
+ },
+ )
+ .await
+ .expect("updated");
+ assert_eq!(updated.member_ids, vec![user(OTHER)]);
+}
+
+#[tokio::test]
+async fn update_filters_owner_from_replacement_members() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_detail()
+ .return_once(|_| Box::pin(async { Ok(Some(detail(Vec::new()))) }));
+ repo.expect_update()
+ .withf(|args| {
+ args.member_ids_added == vec![user(MEMBER)] && args.member_ids_removed.is_empty()
+ })
+ .return_once(|_| Box::pin(async { Ok(detail(vec![user(MEMBER)])) }));
+
+ service(repo)
+ .update(
+ owner_edit_receipt(),
+ UpdateInitiativeRequest {
+ member_ids: Some(vec![OWNER.into(), MEMBER.into()]),
+ ..Default::default()
+ },
+ )
+ .await
+ .expect("updated");
+}
+
+#[tokio::test]
+async fn update_rejects_bad_member_id() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_detail()
+ .return_once(|_| Box::pin(async { Ok(Some(detail(Vec::new()))) }));
+ let result = service(repo)
+ .update(
+ edit_receipt(),
+ UpdateInitiativeRequest {
+ member_ids: Some(vec!["nope".into()]),
+ ..Default::default()
+ },
+ )
+ .await;
+ assert!(matches!(result, Err(InitiativeError::BadRequest(_))));
+}
+
+#[tokio::test]
+async fn owner_can_patch_share_permission() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_team_share_facts()
+ .return_once(|_| Box::pin(async { Ok(team_facts()) }));
+ repo.expect_update()
+ .withf(|args| args.team_share.is_some())
+ .return_once(|_| Box::pin(async { Ok(detail(Vec::new())) }));
+
+ service(repo)
+ .update(
+ owner_edit_receipt(),
+ UpdateInitiativeRequest {
+ share_permission: Some(share_update()),
+ ..Default::default()
+ },
+ )
+ .await
+ .expect("updated");
+}
+
+#[tokio::test]
+async fn assign_rejects_non_initiative_receipts() {
+ let repo = MockInitiativeRepo::new();
+ let document_receipt: EntityAccessReceipt<EditAccessLevel> =
+ receipt(OWNER, EntityType::Document, AccessLevel::Edit);
+ let result = service(repo)
+ .assign_tasks(
+ document_receipt,
+ vec![TaskAssignment::Candidate {
+ task_id: "task-1".into(),
+ }],
+ )
+ .await;
+ assert!(matches!(result, Err(InitiativeError::BadRequest(_))));
+}
+
+#[tokio::test]
+async fn assign_dedupes_enforces_cap_and_preserves_order() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_assign_tasks()
+ .withf(|_, task_ids| task_ids == &["t1".to_string(), "t2".to_string()])
+ .return_once(|_, _| {
+ Box::pin(async {
+ Ok(vec![
+ AssignTasksResult {
+ task_id: "t1".into(),
+ status: AssignTaskStatus::Assigned,
+ },
+ AssignTasksResult {
+ task_id: "t2".into(),
+ status: AssignTaskStatus::Moved,
+ },
+ ])
+ })
+ });
+
+ let response = service(repo)
+ .assign_tasks(
+ edit_receipt(),
+ vec![
+ TaskAssignment::Candidate {
+ task_id: "t1".into(),
+ },
+ TaskAssignment::SkippedNoPermission {
+ task_id: "skip".into(),
+ },
+ TaskAssignment::Candidate {
+ task_id: "t1".into(),
+ },
+ TaskAssignment::NotFound {
+ task_id: "missing".into(),
+ },
+ TaskAssignment::Candidate {
+ task_id: "t2".into(),
+ },
+ ],
+ )
+ .await
+ .expect("assigned");
+
+ assert_eq!(
+ response.results,
+ vec![
+ AssignTasksResult {
+ task_id: "t1".into(),
+ status: AssignTaskStatus::Assigned,
+ },
+ AssignTasksResult {
+ task_id: "skip".into(),
+ status: AssignTaskStatus::SkippedNoPermission,
+ },
+ AssignTasksResult {
+ task_id: "missing".into(),
+ status: AssignTaskStatus::NotFound,
+ },
+ AssignTasksResult {
+ task_id: "t2".into(),
+ status: AssignTaskStatus::Moved,
+ },
+ ]
+ );
+
+ let over_cap: Vec<TaskAssignment> = (0..=MAX_TASKS_PER_ASSIGN)
+ .map(|i| TaskAssignment::Candidate {
+ task_id: format!("task-{i}"),
+ })
+ .collect();
+ let capped = service(MockInitiativeRepo::new())
+ .assign_tasks(edit_receipt(), over_cap)
+ .await;
+ assert!(matches!(capped, Err(InitiativeError::BadRequest(_))));
+}
+
+#[tokio::test]
+async fn get_list_unassign_and_delete_call_the_repo() {
+ let mut repo = MockInitiativeRepo::new();
+ repo.expect_get_basic().return_once(|_| {
+ Box::pin(async {
+ Ok(Some(InitiativeBasic {
+ id: initiative_id(),
+ name: "Launch".into(),
+ owner_id: user(OWNER),
+ }))
+ })
+ });
+ repo.expect_get_detail()
+ .return_once(|_| Box::pin(async { Ok(Some(detail(Vec::new()))) }));
+ repo.expect_list_accessible().return_once(|_| {
+ Box::pin(async {
+ Ok(InitiativeList {
+ initiatives: vec![InitiativeSummary {
+ id: initiative_id(),
+ name: "Launch".into(),
+ description: None,
+ updated_at: now(),
+ }],
+ })
+ })
+ });
+ repo.expect_unassign_task()
+ .return_once(|_, _| Box::pin(async { Ok(()) }));
+ repo.expect_delete()
+ .return_once(|_| Box::pin(async { Ok(()) }));
+
+ let svc = service(repo);
+ svc.internal_get_basic(initiative_id())
+ .await
+ .expect("basic");
+ svc.get(view_receipt()).await.expect("detail");
+ svc.list(&user(OWNER)).await.expect("list");
+ svc.unassign_task(edit_receipt(), "task-1")
+ .await
+ .expect("unassign");
+ svc.delete(owner_receipt()).await.expect("delete");
+}
diff --git a/crates/initiative/src/inbound.rs b/crates/initiative/src/inbound.rs
new file mode 100644
index 0000000000..74ab3f2bfd
--- /dev/null
+++ b/crates/initiative/src/inbound.rs
@@ -0,0 +1 @@
+//! Inbound (driving) adapters for initiatives.
diff --git a/crates/initiative/src/lib.rs b/crates/initiative/src/lib.rs
new file mode 100644
index 0000000000..3fe6658955
--- /dev/null
+++ b/crates/initiative/src/lib.rs
@@ -0,0 +1,13 @@
+#![deny(missing_docs)]
+//! Initiatives: a named grouping of tasks, following the hexagonal architecture
+//! pattern.
+//!
+//! This crate owns initiative lifecycle and assignment policy.
+
+pub mod domain;
+
+#[cfg(feature = "inbound")]
+pub mod inbound;
+
+#[cfg(feature = "outbound")]
+pub mod outbound;
diff --git a/crates/initiative/src/outbound.rs b/crates/initiative/src/outbound.rs
new file mode 100644
index 0000000000..8a1ba5af09
--- /dev/null
+++ b/crates/initiative/src/outbound.rs
@@ -0,0 +1 @@
+//! Outbound (driven) adapters for initiatives.
diff --git a/tooling/just/rust.just b/tooling/just/rust.just
index 7c5762cb2f..ec01ba9846 100644
--- a/tooling/just/rust.just
+++ b/tooling/just/rust.just
@@ -101,6 +101,7 @@ setup_test_envs:
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/stream/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/entity_access/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/github/.env
+ echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/initiative/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/referral/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/chat/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/memory/.env