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 scaffold and domain layer models ports service (#6424)
Will Hutchinson4365b740714a
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 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.lockindex 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.tomlindex 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.tomlnew file mode 100644index 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.sqlnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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, ¤t.owner_id)?;+ member_diff(¤t.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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.justindex 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/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/entity_access/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/github/.env+ echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/initiative/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/referral/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/chat/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/memory/.env