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(projects): kafka projects producer (#4968)
Will Hutchinson35f25cf35cbc
diff --git a/.github/kafka-cluster-topics.json b/.github/kafka-cluster-topics.jsonindex b0052d835d..6f7ff530df 100644--- a/.github/kafka-cluster-topics.json+++ b/.github/kafka-cluster-topics.json@@ -2,5 +2,6 @@"macro.channels","macro.documents","macro.email",- "macro.example"+ "macro.example",+ "macro.projects"]diff --git a/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.json b/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.jsondeleted file mode 100644index bee4696fc8..0000000000--- a/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.json+++ /dev/null@@ -1,22 +0,0 @@-{- "db_name": "PostgreSQL",- "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id FROM \"Project\" WHERE id = $1\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n )\n UPDATE \"Project\"\n SET \"uploadPending\" = false\n WHERE id IN (SELECT id FROM project_hierarchy)\n RETURNING id\n ",- "describe": {- "columns": [- {- "ordinal": 0,- "name": "id",- "type_info": "Text"- }- ],- "parameters": {- "Left": [- "Text"- ]- },- "nullable": [- false- ]- },- "hash": "73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63"-}diff --git a/.sqlx/query-db481033a92727aba2a32a14415f6ef2d22fd91f94fa57d053192c08bcc63bfc.json b/.sqlx/query-db481033a92727aba2a32a14415f6ef2d22fd91f94fa57d053192c08bcc63bfc.jsonnew file mode 100644index 0000000000..6d8f5a5cb7--- /dev/null+++ b/.sqlx/query-db481033a92727aba2a32a14415f6ef2d22fd91f94fa57d053192c08bcc63bfc.json@@ -0,0 +1,46 @@+{+ "db_name": "PostgreSQL",+ "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id FROM \"Project\" WHERE id = $1\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n ),\n updated_projects AS (\n UPDATE \"Project\"\n SET \"uploadPending\" = false\n WHERE id IN (SELECT id FROM project_hierarchy)\n AND \"uploadPending\" = true\n RETURNING id\n )\n SELECT\n project.id,\n project.name,\n project.\"userId\" AS user_id,\n project.\"parentId\" AS parent_id,\n EXISTS (\n SELECT 1 FROM updated_projects WHERE id = $1\n ) AS \"upload_pending_transitioned!\"\n FROM \"Project\" project\n JOIN project_hierarchy hierarchy ON hierarchy.id = project.id\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Text"+ },+ {+ "ordinal": 1,+ "name": "name",+ "type_info": "Text"+ },+ {+ "ordinal": 2,+ "name": "user_id",+ "type_info": "Text"+ },+ {+ "ordinal": 3,+ "name": "parent_id",+ "type_info": "Text"+ },+ {+ "ordinal": 4,+ "name": "upload_pending_transitioned!",+ "type_info": "Bool"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ false,+ false,+ false,+ true,+ null+ ]+ },+ "hash": "db481033a92727aba2a32a14415f6ef2d22fd91f94fa57d053192c08bcc63bfc"+}diff --git a/Cargo.lock b/Cargo.lockindex 8ac6a2ba0a..b0bcbc0ef7 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -11020,6 +11020,8 @@ dependencies = ["macro_db_migrator","macro_env","macro_env_var",+ "macro_event_broker",+ "macro_event_topics","macro_sha_count_client","macro_user_id","macro_uuid",@@ -11030,6 +11032,7 @@ dependencies = ["model_user","models_bulk_upload","models_permissions",+ "rdkafka","rootcause","s3_key","serde",@@ -11041,6 +11044,7 @@ dependencies = ["tokio","tower 0.5.3","tracing",+ "tracing-subscriber","unicode-segmentation","utoipa","uuid",diff --git a/crates/macro_event_broker/src/lib.rs b/crates/macro_event_broker/src/lib.rsindex 25ba7464d9..f96c21aae1 100644--- a/crates/macro_event_broker/src/lib.rs+++ b/crates/macro_event_broker/src/lib.rs@@ -15,7 +15,8 @@ pub mod domain;pub use domain::models::{Event, EventBrokerError, MacroEvent, TopicEvent};pub use macro_event_topics::{- MacroChannelsTopic, MacroDocumentsTopic, MacroEmailTopic, MacroExampleTopic, Topic,+ MacroChannelsTopic, MacroDocumentsTopic, MacroEmailTopic, MacroExampleTopic,+ MacroProjectsTopic, Topic,};#[cfg(feature = "ports")]diff --git a/crates/macro_event_topics/src/lib.rs b/crates/macro_event_topics/src/lib.rsindex 61fcf897cc..6fe2e3c91e 100644--- a/crates/macro_event_topics/src/lib.rs+++ b/crates/macro_event_topics/src/lib.rs@@ -51,6 +51,8 @@ topics! {MacroExampleTopic => "macro.example",/// Document lifecycle events (created / updated / deleted / copied).MacroDocumentsTopic => "macro.documents",+ /// Project lifecycle events (created, updated, deleted, restored, permanently deleted, and uploaded).+ MacroProjectsTopic => "macro.projects",/// Channel lifecycle, message, participant, and attachment events.MacroChannelsTopic => "macro.channels",/// Email lifecycle events (links, messages, threads, labels).diff --git a/crates/macro_event_topics/src/test.rs b/crates/macro_event_topics/src/test.rsindex 5b86f9203d..826b241a42 100644--- a/crates/macro_event_topics/src/test.rs+++ b/crates/macro_event_topics/src/test.rs@@ -19,5 +19,6 @@ fn all_topic_names_is_non_empty_and_unique() {fn all_topic_names_includes_declared_topics() {assert!(all_topic_names().contains(&MacroExampleTopic.as_str()));assert!(all_topic_names().contains(&MacroDocumentsTopic.as_str()));+ assert!(all_topic_names().contains(&MacroProjectsTopic.as_str()));assert!(all_topic_names().contains(&MacroChannelsTopic.as_str()));}diff --git a/crates/projects/Cargo.toml b/crates/projects/Cargo.tomlindex bf34df76f7..4dae5b8b20 100644--- a/crates/projects/Cargo.toml+++ b/crates/projects/Cargo.toml@@ -32,6 +32,7 @@ outbound = [ports = ["dep:tokio"]service = ["dep:entity_access_management",+ "macro_event_broker/ports","ports",]@@ -55,6 +56,8 @@ entity_access_management = { path = "../entity_access_management", default-featu], optional = true }macro_aws_config = { path = "../macro_aws_config", features = ["s3"] }macro_env_var = { path = "../macro_env_var" }+macro_event_broker = { path = "../macro_event_broker", default-features = false }+macro_event_topics = { path = "../macro_event_topics" }macro_user_id = { path = "../macro_user_id" }macro_uuid = { path = "../macro_uuid" }model = { path = "../model" }@@ -94,9 +97,13 @@ dotenvy = { workspace = true }http-body-util = { workspace = true }macro_db_migrator = { path = "../macro_db_migrator" }macro_env = { path = "../macro_env" }+# Examples need the Kafka adapter (outbound); the library itself only uses ports.+macro_event_broker = { path = "../macro_event_broker" }mockall = { workspace = true }+rdkafka = { workspace = true }model_user = { path = "../model_user" }rootcause = { workspace = true }serde_json = { workspace = true }-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal"] }tower = { workspace = true }+tracing-subscriber = { workspace = true }diff --git a/crates/projects/examples/projects_consumer.rs b/crates/projects/examples/projects_consumer.rsnew file mode 100644index 0000000000..b64f5dcd10--- /dev/null+++ b/crates/projects/examples/projects_consumer.rs@@ -0,0 +1,268 @@+//! Kafka consumer example for the `macro.projects` topic.+//!+//! Connects with the same `KAFKA_BROKERS` env var and environment-driven+//! transport as [`macro_event_broker::KafkaEventPublisher`] (plaintext for+//! `ENVIRONMENT=local`, TLS + SASL/OAUTHBEARER with MSK IAM otherwise),+//! subscribes to [`MacroProjectsTopic`], and prints every project lifecycle+//! event it receives.+//!+//! The consumer follows the standard poll-loop / worker split: a Kafka poll+//! loop decodes messages and hands them to a processing task over a bounded+//! tokio mpsc channel (backpressure applies when the processor falls behind),+//! offsets are committed only after a successful handoff (at-least-once), and+//! ctrl-c drains the channel before exiting.+//!+//! Run against the local docker broker:+//! ```sh+//! ENVIRONMENT=local KAFKA_BROKERS=localhost:9092 \+//! cargo run -p projects --example projects_consumer+//! ```+//! or against the dev MSK cluster (needs AWS credentials and network access):+//! ```sh+//! ENVIRONMENT=develop AWS_REGION=us-east-1 KAFKA_BROKERS=<bootstrapBrokersSaslIam> \+//! cargo run -p projects --example projects_consumer+//! ```++use anyhow::Context as _;+use macro_env::Environment;+use macro_event_broker::outbound::msk_iam::configure_sasl_iam;+use macro_event_broker::{EventBrokerError, MacroEvent, MskIamClientContext, Topic as _};+use macro_event_topics::MacroProjectsTopic;+use projects::domain::events::{ProjectMacroEvent, ProjectTopicEvent};+use rdkafka::ClientConfig;+use rdkafka::consumer::{CommitMode, Consumer, StreamConsumer};+use rdkafka::error::KafkaResult;+use rdkafka::message::{BorrowedMessage, Message};+use tokio::sync::mpsc;++macro_env_var::env_var! {+ struct ConsumerEnvVars {+ KafkaBrokers,+ }+}++/// Consumer group id for this example. Offsets are committed under this group,+/// so re-runs resume where the previous run left off.+const GROUP_ID: &str = "projects-consumer-example";++/// Bounded capacity of the channel between the poll loop and the processor.+const CHANNEL_CAPACITY: usize = 128;++/// Consumer-specific event enum for a consumer subscribed to `macro.projects`,+/// following the pattern in `macro_event_broker/examples/example_event.rs`.+enum ProjectsConsumerEvent {+ /// Event received on [`MacroProjectsTopic`].+ Projects(ProjectMacroEvent),+}++impl ProjectsConsumerEvent {+ /// Decode one Kafka message into this consumer's event enum.+ fn decode(topic: &str, key: &str, payload: &[u8]) -> Result<Self, EventBrokerError> {+ match topic {+ topic if topic == MacroProjectsTopic.as_str() => {+ Ok(Self::Projects(ProjectMacroEvent::decode(key, payload)?))+ }+ unknown => Err(EventBrokerError::UnknownTopic(unknown.to_string())),+ }+ }+}++/// A decoded event plus the Kafka coordinates it came from, as handed from the+/// poll loop to the processor over the channel.+struct ReceivedEvent {+ partition: i32,+ offset: i64,+ event: ProjectsConsumerEvent,+}++/// The underlying consumer, split by transport (mirrors `KafkaEventPublisher`).+enum ProjectsConsumer {+ /// Unauthenticated plaintext connection (local docker broker).+ Plaintext(StreamConsumer),+ /// TLS + SASL/OAUTHBEARER with AWS MSK IAM auth (deployed clusters).+ MskIam(StreamConsumer<MskIamClientContext>),+}++impl ProjectsConsumer {+ /// Build a consumer for the given brokers, choosing the transport from the+ /// `ENVIRONMENT` variable exactly like the publisher does.+ fn from_env(brokers: &str) -> anyhow::Result<Self> {+ let mut config = ClientConfig::new();+ config+ .set("bootstrap.servers", brokers)+ .set("group.id", GROUP_ID)+ // Offsets are committed manually after a successful handoff.+ .set("enable.auto.commit", "false")+ // Start from the beginning of the topic on the first ever run.+ .set("auto.offset.reset", "earliest");++ let consumer = match Environment::new_or_prod() {+ Environment::Local => Self::Plaintext(+ config+ .create()+ .context("failed to create plaintext kafka consumer")?,+ ),+ Environment::Develop | Environment::Production => {+ configure_sasl_iam(&mut config);+ Self::MskIam(+ config+ .create_with_context(MskIamClientContext::from_env())+ .context("failed to create MSK IAM kafka consumer")?,+ )+ }+ };++ Ok(consumer)+ }++ fn subscribe(&self) -> KafkaResult<()> {+ let topics = [MacroProjectsTopic.as_str()];+ match self {+ Self::Plaintext(consumer) => consumer.subscribe(&topics),+ Self::MskIam(consumer) => consumer.subscribe(&topics),+ }+ }++ /// Receive the next message. `StreamConsumer::recv` is cancel-safe, so it+ /// can sit in a `select!` without losing messages.+ async fn recv(&self) -> KafkaResult<BorrowedMessage<'_>> {+ match self {+ Self::Plaintext(consumer) => consumer.recv().await,+ Self::MskIam(consumer) => consumer.recv().await,+ }+ }++ fn commit(&self, message: &BorrowedMessage<'_>) -> KafkaResult<()> {+ match self {+ Self::Plaintext(consumer) => consumer.commit_message(message, CommitMode::Async),+ Self::MskIam(consumer) => consumer.commit_message(message, CommitMode::Async),+ }+ }+}++fn event_type(event: &ProjectTopicEvent) -> &'static str {+ match event {+ ProjectTopicEvent::Created(_) => "project.created",+ ProjectTopicEvent::Updated(_) => "project.updated",+ ProjectTopicEvent::Deleted(_) => "project.deleted",+ ProjectTopicEvent::Restored(_) => "project.restored",+ ProjectTopicEvent::PermanentlyDeleted(_) => "project.permanently_deleted",+ ProjectTopicEvent::Uploaded(_) => "project.uploaded",+ }+}++/// Print each received event. This stands in for real event handling — swap+/// the body for indexing, notifications, etc.+async fn process_events(mut events: mpsc::Receiver<ReceivedEvent>) {+ while let Some(received) = events.recv().await {+ let ProjectsConsumerEvent::Projects(event) = received.event;+ let envelope = event.event();++ println!(+ "[partition {} offset {}] {} key={} event_id={} schema_version={}",+ received.partition,+ received.offset,+ event_type(&envelope.event),+ event.key(),+ envelope.event_id,+ envelope.schema_version,+ );+ match serde_json::to_string_pretty(envelope) {+ Ok(json) => println!("{json}"),+ Err(e) => eprintln!("failed to re-serialize event: {e}"),+ }+ }+}++#[tokio::main]+async fn main() -> anyhow::Result<()> {+ // Surface tracing from macro_event_broker (e.g. MSK IAM token refreshes)+ // and librdkafka's internal connection/auth logs (bridged from the `log`+ // crate). Tune with RUST_LOG, e.g. RUST_LOG=debug for librdkafka detail.+ tracing_subscriber::fmt()+ .with_env_filter(+ tracing_subscriber::EnvFilter::try_from_default_env()+ .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),+ )+ .init();++ let env = ConsumerEnvVars::new().context("KAFKA_BROKERS must be set")?;++ let consumer = ProjectsConsumer::from_env(env.kafka_brokers.as_ref())?;+ consumer+ .subscribe()+ .context("failed to subscribe to projects topic")?;+ println!(+ "listening on topic={} group={} brokers={} (ctrl-c to stop)",+ MacroProjectsTopic.as_str(),+ GROUP_ID,+ env.kafka_brokers.as_ref(),+ );++ let (events_tx, events_rx) = mpsc::channel::<ReceivedEvent>(CHANNEL_CAPACITY);+ let processor = tokio::spawn(process_events(events_rx));++ let mut shutdown = std::pin::pin!(tokio::signal::ctrl_c());+ loop {+ tokio::select! {+ _ = &mut shutdown => {+ println!("received ctrl-c, shutting down");+ break;+ }+ result = consumer.recv() => {+ let message = match result {+ Ok(message) => message,+ Err(e) => {+ eprintln!("kafka receive error: {e}");+ continue;+ }+ };++ let Some(payload) = message.payload() else {+ eprintln!(+ "skipping message with empty payload at partition {} offset {}",+ message.partition(),+ message.offset(),+ );+ let _ = consumer.commit(&message).inspect_err(|e| {+ eprintln!("failed to commit offset {}: {e}", message.offset());+ });+ continue;+ };+ let key = String::from_utf8_lossy(message.key().unwrap_or_default());++ match ProjectsConsumerEvent::decode(message.topic(), key.as_ref(), payload) {+ Ok(event) => {+ events_tx+ .send(ReceivedEvent {+ partition: message.partition(),+ offset: message.offset(),+ event,+ })+ .await+ .context("processor task closed unexpectedly")?;+ }+ // Undecodable messages are logged and skipped rather than+ // wedging the partition on a poison message.+ Err(e) => eprintln!(+ "failed to decode message at partition {} offset {}: {e}",+ message.partition(),+ message.offset(),+ ),+ }++ // Commit only after the event was handed to the processor:+ // at-least-once delivery (up to the channel buffer on a crash).+ let _ = consumer.commit(&message).inspect_err(|e| {+ eprintln!("failed to commit offset {}: {e}", message.offset());+ });+ }+ }+ }++ // Close the channel and let the processor drain what it already received.+ drop(events_tx);+ processor.await.context("processor task panicked")?;++ Ok(())+}diff --git a/crates/projects/src/domain.rs b/crates/projects/src/domain.rsindex 6a5d4f077f..c811c4bb28 100644--- a/crates/projects/src/domain.rs+++ b/crates/projects/src/domain.rs@@ -1,5 +1,6 @@//! Domain models, ports, and project service definitions.+pub mod events;pub mod models;pub mod response;diff --git a/crates/projects/src/domain/events.rs b/crates/projects/src/domain/events.rsnew file mode 100644index 0000000000..f274c75597--- /dev/null+++ b/crates/projects/src/domain/events.rs@@ -0,0 +1,211 @@+//! Kafka event models for the `macro.projects` topic.++use chrono::{DateTime, Utc};+use macro_event_broker::{Event, MacroEvent, TopicEvent};+use macro_event_topics::MacroProjectsTopic;+use macro_user_id::user_id::MacroUserIdStr;+use serde::{Deserialize, Serialize};++/// Metadata for [`ProjectTopicEvent::Created`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectCreatedMetadata {+ /// The id of the created project.+ pub project_id: String,+ /// The owner and creator of the project.+ pub owner: MacroUserIdStr<'static>,+ /// The project name.+ pub name: String,+ /// The parent project id, when the project has a parent.+ pub parent_project_id: Option<String>,+ /// The creation timestamp reported by the repository.+ pub created_at: Option<DateTime<Utc>>,+}++/// Metadata for [`ProjectTopicEvent::Updated`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectUpdatedMetadata {+ /// The id of the updated project.+ pub project_id: String,+ /// The owner of the project.+ pub owner: MacroUserIdStr<'static>,+ /// The authenticated user who performed the update, if any.+ pub actor_user_id: Option<MacroUserIdStr<'static>>,+ /// The new project name, or `None` when unchanged.+ pub name: Option<String>,+ /// The parent project id before the update.+ pub previous_parent_id: Option<String>,+ /// The requested parent project id; `None` means unchanged and `Some("")` means root.+ pub parent_id: Option<String>,+ /// Whether share permissions were updated.+ pub share_permission_updated: bool,+}++/// Metadata for [`ProjectTopicEvent::Deleted`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectDeletedMetadata {+ /// The id of the root project that was deleted.+ pub project_id: String,+ /// The owner of the root project.+ pub owner: MacroUserIdStr<'static>,+ /// The authenticated user who performed the deletion, if any.+ pub actor_user_id: Option<MacroUserIdStr<'static>>,+ /// The parent of the root project, when any.+ pub parent_project_id: Option<String>,+ /// The ids of all projects deleted in the cascade.+ pub deleted_project_ids: Vec<String>,+ /// The ids of all documents deleted in the cascade.+ pub deleted_document_ids: Vec<String>,+ /// The ids of all chats deleted in the cascade.+ pub deleted_chat_ids: Vec<String>,+}++/// Metadata for [`ProjectTopicEvent::Restored`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectRestoredMetadata {+ /// The id of the root project that was restored.+ pub project_id: String,+ /// The owner of the root project.+ pub owner: MacroUserIdStr<'static>,+ /// The authenticated user who performed the restoration, if any.+ pub actor_user_id: Option<MacroUserIdStr<'static>>,+ /// The parent under which the root project was restored, when any.+ pub parent_project_id: Option<String>,+ /// The ids of all projects restored in the cascade.+ pub restored_project_ids: Vec<String>,+}++/// Metadata for [`ProjectTopicEvent::PermanentlyDeleted`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectPermanentlyDeletedMetadata {+ /// The id of the root project that was permanently deleted.+ pub project_id: String,+ /// The owner of the root project.+ pub owner: MacroUserIdStr<'static>,+ /// The authenticated user who performed the deletion, if any.+ pub actor_user_id: Option<MacroUserIdStr<'static>>,+ /// The parent of the root project, when any.+ pub parent_project_id: Option<String>,+ /// The ids of all projects purged in the cascade.+ pub purged_project_ids: Vec<String>,+ /// The ids of all documents purged in the cascade.+ pub purged_document_ids: Vec<String>,+ /// The ids of all chats purged in the cascade.+ pub purged_chat_ids: Vec<String>,+}++/// Metadata for [`ProjectTopicEvent::Uploaded`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct ProjectUploadedMetadata {+ /// The id of the root project in the uploaded tree.+ pub root_project_id: String,+ /// The owner of the uploaded tree.+ pub owner: MacroUserIdStr<'static>,+ /// The name of the root project.+ pub name: String,+ /// The parent of the root project, when any.+ pub parent_project_id: Option<String>,+ /// The ids of all projects made live in the uploaded tree.+ pub project_ids: Vec<String>,+}++/// Events that can be published to [`MacroProjectsTopic`].+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+#[serde(tag = "event_type", content = "metadata")]+pub enum ProjectTopicEvent {+ /// A project was created.+ #[serde(rename = "project.created")]+ Created(ProjectCreatedMetadata),+ /// A project's metadata or permissions were updated.+ #[serde(rename = "project.updated")]+ Updated(ProjectUpdatedMetadata),+ /// A project tree was soft-deleted.+ #[serde(rename = "project.deleted")]+ Deleted(ProjectDeletedMetadata),+ /// A project tree was restored.+ #[serde(rename = "project.restored")]+ Restored(ProjectRestoredMetadata),+ /// A project tree was permanently deleted.+ #[serde(rename = "project.permanently_deleted")]+ PermanentlyDeleted(ProjectPermanentlyDeletedMetadata),+ /// An uploaded project tree was made live.+ #[serde(rename = "project.uploaded")]+ Uploaded(ProjectUploadedMetadata),+}++impl TopicEvent for ProjectTopicEvent {+ type Topic = MacroProjectsTopic;++ fn schema_version(&self) -> u8 {+ 1+ }+}++/// Publishable event for [`MacroProjectsTopic`], keyed by the root project id.+pub struct ProjectMacroEvent {+ key: String,+ event: Event<ProjectTopicEvent>,+}++impl ProjectMacroEvent {+ /// Builds a created event keyed by the new project id.+ pub fn created(key: impl Into<String>, metadata: ProjectCreatedMetadata) -> Self {+ Self::new(key, ProjectTopicEvent::Created(metadata))+ }++ /// Builds an updated event keyed by the updated project id.+ pub fn updated(key: impl Into<String>, metadata: ProjectUpdatedMetadata) -> Self {+ Self::new(key, ProjectTopicEvent::Updated(metadata))+ }++ /// Builds a deleted event keyed by the root project id.+ pub fn deleted(key: impl Into<String>, metadata: ProjectDeletedMetadata) -> Self {+ Self::new(key, ProjectTopicEvent::Deleted(metadata))+ }++ /// Builds a restored event keyed by the root project id.+ pub fn restored(key: impl Into<String>, metadata: ProjectRestoredMetadata) -> Self {+ Self::new(key, ProjectTopicEvent::Restored(metadata))+ }++ /// Builds a permanently deleted event keyed by the root project id.+ pub fn permanently_deleted(+ key: impl Into<String>,+ metadata: ProjectPermanentlyDeletedMetadata,+ ) -> Self {+ Self::new(key, ProjectTopicEvent::PermanentlyDeleted(metadata))+ }++ /// Builds an uploaded event keyed by the root project id.+ pub fn uploaded(key: impl Into<String>, metadata: ProjectUploadedMetadata) -> Self {+ Self::new(key, ProjectTopicEvent::Uploaded(metadata))+ }++ /// Builds an event from a topic-specific project event.+ pub fn new(key: impl Into<String>, event: ProjectTopicEvent) -> Self {+ Self::with_event(key, Event::new(event))+ }++ /// Builds an event from a pre-built envelope.+ pub fn with_event(key: impl Into<String>, event: Event<ProjectTopicEvent>) -> Self {+ Self {+ key: key.into(),+ event,+ }+ }+}++impl MacroEvent for ProjectMacroEvent {+ type EventPayload = ProjectTopicEvent;++ fn key(&self) -> &str {+ &self.key+ }++ fn event(&self) -> &Event<Self::EventPayload> {+ &self.event+ }++ fn from_event(key: String, event: Event<Self::EventPayload>) -> Self {+ Self::with_event(key, event)+ }+}diff --git a/crates/projects/src/domain/models.rs b/crates/projects/src/domain/models.rsindex d9e9bd52bb..85c9620e40 100644--- a/crates/projects/src/domain/models.rs+++ b/crates/projects/src/domain/models.rs@@ -64,6 +64,23 @@ pub struct PurgedProjectTree {pub bom_shas: Vec<(String, i64)>,}+/// Metadata for a project tree finalized after upload.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct MarkedUploadedTree {+ /// Root project identifier.+ pub id: String,+ /// Root project name.+ pub name: String,+ /// Root project owner.+ pub user_id: MacroUserIdStr<'static>,+ /// Optional parent of the root project.+ pub parent_id: Option<String>,+ /// Finalized project identifiers, including the root and all descendants.+ pub project_ids: Vec<String>,+ /// Whether the root project's upload-pending state transitioned to finalized.+ pub upload_pending_transitioned: bool,+}+/// Arguments for creating a pending project tree for a folder upload.#[derive(Debug)]pub struct UploadFolderRepoArgs {diff --git a/crates/projects/src/domain/ports.rs b/crates/projects/src/domain/ports.rsindex bb0b36cc7a..6094684d42 100644--- a/crates/projects/src/domain/ports.rs+++ b/crates/projects/src/domain/ports.rs@@ -28,8 +28,8 @@ use s3_key::BulkUploadStagingKey;use uuid::Uuid;use super::models::{- CreateProjectArgs, EditProjectArgs, MutatedProject, ProjectError, PurgedProjectTree,- RevertDeleteResult, SoftDeleteResult, UploadFolderRepoArgs,+ CreateProjectArgs, EditProjectArgs, MarkedUploadedTree, MutatedProject, ProjectError,+ PurgedProjectTree, RevertDeleteResult, SoftDeleteResult, UploadFolderRepoArgs,};/// Repository for reading project data from persistent storage.@@ -138,7 +138,7 @@ pub trait ProjectRepo: Send + Sync + 'static {fn mark_projects_uploaded(&self,root_project_id: &str,- ) -> impl Future<Output = Result<Vec<String>, Self::Err>> + Send;+ ) -> impl Future<Output = Result<MarkedUploadedTree, Self::Err>> + Send;/// Update the project's modified timestamp.fn update_project_modified(@@ -304,6 +304,7 @@ pub trait ProjectService: Send + Sync + 'static {fn permanently_delete_project(&self,receipt: EntityAccessReceipt<OwnerAccessLevel>,+ project: BasicProject,) -> impl Future<Output = Result<(), ProjectError>> + Send;/// Restore a soft-deleted project subtree.diff --git a/crates/projects/src/domain/service.rs b/crates/projects/src/domain/service.rsindex 16fb86160a..cb31e642a4 100644--- a/crates/projects/src/domain/service.rs+++ b/crates/projects/src/domain/service.rs@@ -8,6 +8,7 @@ use entity_access::domain::models::{};use entity_access_management::domain::ports::EntityAccessManagementService;use futures::stream::{FuturesUnordered, StreamExt};+use macro_event_broker::MacroEventBroker;use macro_user_id::user_id::MacroUserIdStr;use model::folder::{UploadFolderRequest, UploadFolderResponseData};use model::item::{Item, ItemWithUserAccessLevel};@@ -24,6 +25,11 @@ use s3_key::BulkUploadStagingKey;use unicode_segmentation::UnicodeSegmentation;use uuid::Uuid;+use super::events::{+ ProjectCreatedMetadata, ProjectDeletedMetadata, ProjectMacroEvent,+ ProjectPermanentlyDeletedMetadata, ProjectRestoredMetadata, ProjectUpdatedMetadata,+ ProjectUploadedMetadata,+};use super::models::{CreateProjectArgs, EditProjectArgs, ProjectError, SoftDeleteResult, UploadFolderRepoArgs,};@@ -38,8 +44,19 @@ mod tests;const MAX_PROJECT_NAME_GRAPHEMES: usize = 100;+/// The user id to attribute a project lifecycle event to, when the caller is an+/// authenticated user.+fn event_actor_user_id(auth: &EntityAccessAuth) -> Option<MacroUserIdStr<'static>> {+ match auth {+ EntityAccessAuth::Authenticated(user_id) => Some(user_id.clone()),+ EntityAccessAuth::Bot(_)+ | EntityAccessAuth::Unauthenticated+ | EntityAccessAuth::Internal => None,+ }+}+/// Concrete project service backed by repository and external-system ports.-pub struct ProjectServiceImpl<R, U, D, Sha, Eam, Idx>+pub struct ProjectServiceImpl<R, U, D, Sha, Eam, Idx, B>whereR: ProjectRepo,U: ProjectUploadUrlPort,@@ -47,6 +64,7 @@ whereSha: ShaCounterPort,Eam: EntityAccessManagementService,Idx: ProjectSearchIndexer,+ B: MacroEventBroker,{/// Project repository.pub repo: R,@@ -60,11 +78,13 @@ wherepub entity_access_management_service: Eam,/// Search and deletion queue publisher.pub search_indexer: Idx,+ /// Project lifecycle event broker.+ pub macro_event_broker: B,/// Optional deterministic upload request ID used by local development.pub fixed_upload_request_id: Option<Uuid>,}-impl<R, U, D, Sha, Eam, Idx> ProjectServiceImpl<R, U, D, Sha, Eam, Idx>+impl<R, U, D, Sha, Eam, Idx, B> ProjectServiceImpl<R, U, D, Sha, Eam, Idx, B>whereR: ProjectRepo,U: ProjectUploadUrlPort,@@ -72,6 +92,7 @@ whereSha: ShaCounterPort,Eam: EntityAccessManagementService,Idx: ProjectSearchIndexer,+ B: MacroEventBroker,{/// Create a project service from its repository and external-system ports.#[allow(clippy::too_many_arguments)]@@ -83,6 +104,7 @@ whereentity_access_management_service: Eam,search_indexer: Idx,fixed_upload_request_id: Option<Uuid>,+ macro_event_broker: B,) -> Self {Self {repo,@@ -91,10 +113,21 @@ wheresha_counter,entity_access_management_service,search_indexer,+ macro_event_broker,fixed_upload_request_id,}}+ /// Publish a project lifecycle event; failures are logged and dropped.+ fn publish_project_event(&self, event: &ProjectMacroEvent) {+ let _ = self+ .macro_event_broker+ .send_event(event)+ .inspect_err(|error| {+ tracing::error!(error=?error, "failed to publish project event");+ });+ }+async fn bump_project_modified(&self, project_id: &str) {let _ = self.repo@@ -121,7 +154,7 @@ where}}-impl<R, U, D, Sha, Eam, Idx> ProjectService for ProjectServiceImpl<R, U, D, Sha, Eam, Idx>+impl<R, U, D, Sha, Eam, Idx, B> ProjectService for ProjectServiceImpl<R, U, D, Sha, Eam, Idx, B>whereR: ProjectRepo,U: ProjectUploadUrlPort,@@ -129,6 +162,7 @@ whereSha: ShaCounterPort,Eam: EntityAccessManagementService,Idx: ProjectSearchIndexer,+ B: MacroEventBroker,{async fn list_projects(&self,@@ -334,6 +368,17 @@ whereself.bump_project_modified(&parent_id.to_string()).await;}+ self.publish_project_event(&ProjectMacroEvent::created(+ project.id.clone(),+ ProjectCreatedMetadata {+ project_id: project.id.clone(),+ owner: actor,+ name: project.name.clone(),+ parent_project_id: project.parent_id.clone(),+ created_at: project.created_at,+ },+ ));+Ok(project)}@@ -350,6 +395,10 @@ wherevalidate_project_name(name)?;}+ let requested_name = args.name.clone();+ let requested_parent_id = args.project_parent_id.clone();+ let share_permission_updated = args.share_permission.is_some();+let is_owner = receipt_is_owner(&receipt);if args.project_parent_id.is_some() && !is_owner {return Err(ProjectError::UnauthorizedWithMessage(@@ -429,6 +478,20 @@ whereself.bump_project_modified(parent_id).await;}+ let project_id = receipt.entity().entity_id.clone();+ self.publish_project_event(&ProjectMacroEvent::updated(+ project_id.clone(),+ ProjectUpdatedMetadata {+ project_id,+ owner: project.user_id,+ actor_user_id: event_actor_user_id(receipt.auth()),+ name: requested_name,+ previous_parent_id: project.parent_id,+ parent_id: requested_parent_id,+ share_permission_updated,+ },+ ));+Ok(())}@@ -457,12 +520,27 @@ whereself.bump_project_modified(parent_id).await;}+ let project_id = receipt.entity().entity_id.clone();+ self.publish_project_event(&ProjectMacroEvent::deleted(+ project_id.clone(),+ ProjectDeletedMetadata {+ project_id,+ owner: project.user_id,+ actor_user_id: event_actor_user_id(receipt.auth()),+ parent_project_id: project.parent_id,+ deleted_project_ids: deleted.project_ids.clone(),+ deleted_document_ids: deleted.document_ids.clone(),+ deleted_chat_ids: deleted.chat_ids.clone(),+ },+ ));+Ok(deleted)}async fn permanently_delete_project(&self,receipt: EntityAccessReceipt<OwnerAccessLevel>,+ project: BasicProject,) -> Result<(), ProjectError> {let purged = self.repo@@ -477,6 +555,14 @@ where.map_err(|error| internal_error(error, "unable to update document references"))?;}+ let purged_project_ids = purged.project_ids.clone();+ let purged_chat_ids = purged.chat_ids.clone();+ let purged_document_ids = purged+ .documents+ .iter()+ .map(|(document_id, _)| document_id.clone())+ .collect::<Vec<_>>();+if !purged.project_ids.is_empty() {let _ = self.search_indexer@@ -492,14 +578,9 @@ where.inspect_err(|error| tracing::error!(error = ?error, "unable to enqueue purged chats for search"));}if !purged.documents.is_empty() {- let document_ids = purged- .documents- .iter()- .map(|(document_id, _)| document_id.clone())- .collect();let _ = self.search_indexer- .remove_documents(document_ids)+ .remove_documents(purged_document_ids.clone()).await.inspect_err(|error| tracing::error!(error = ?error, "unable to enqueue purged documents for search"));let _ = self@@ -511,6 +592,20 @@ where);}+ let project_id = receipt.entity().entity_id.clone();+ self.publish_project_event(&ProjectMacroEvent::permanently_deleted(+ project_id.clone(),+ ProjectPermanentlyDeletedMetadata {+ project_id,+ owner: project.user_id,+ actor_user_id: event_actor_user_id(receipt.auth()),+ parent_project_id: project.parent_id,+ purged_project_ids,+ purged_document_ids,+ purged_chat_ids,+ },+ ));+Ok(())}@@ -519,21 +614,35 @@ wherereceipt: EntityAccessReceipt<OwnerAccessLevel>,project: BasicProject,) -> Result<(), ProjectError> {+ let parent_project_id = project.parent_id.clone();let restored = self.repo- .revert_delete_project(&receipt.entity().entity_id, project.parent_id)+ .revert_delete_project(&receipt.entity().entity_id, parent_project_id.clone()).await.map_err(|error| internal_error(error, "unable to revert project"))?;if !restored.project_ids.is_empty() {let _ = self.search_indexer- .upsert_projects(restored.project_ids)+ .upsert_projects(restored.project_ids.clone()).await.inspect_err(|error| {tracing::error!(error = ?error, "unable to enqueue restored projects for search");});}++ let project_id = receipt.entity().entity_id.clone();+ self.publish_project_event(&ProjectMacroEvent::restored(+ project_id.clone(),+ ProjectRestoredMetadata {+ project_id,+ owner: project.user_id,+ actor_user_id: event_actor_user_id(receipt.auth()),+ parent_project_id,+ restored_project_ids: restored.project_ids,+ },+ ));+Ok(())}@@ -636,10 +745,26 @@ where&self,root_project_id: &str,) -> Result<Vec<String>, ProjectError> {- self.repo+ let uploaded_tree = self+ .repo.mark_projects_uploaded(root_project_id).await- .map_err(|error| internal_error(error, "unable to mark projects uploaded"))+ .map_err(|error| internal_error(error, "unable to mark projects uploaded"))?;++ if uploaded_tree.upload_pending_transitioned {+ self.publish_project_event(&ProjectMacroEvent::uploaded(+ uploaded_tree.id.clone(),+ ProjectUploadedMetadata {+ root_project_id: uploaded_tree.id,+ owner: uploaded_tree.user_id,+ name: uploaded_tree.name,+ parent_project_id: uploaded_tree.parent_id,+ project_ids: uploaded_tree.project_ids.clone(),+ },+ ));+ }++ Ok(uploaded_tree.project_ids)}async fn get_batch_preview(diff --git a/crates/projects/src/domain/service/tests.rs b/crates/projects/src/domain/service/tests.rsindex ae62ebac47..907ea85acf 100644--- a/crates/projects/src/domain/service/tests.rs+++ b/crates/projects/src/domain/service/tests.rs@@ -6,6 +6,7 @@ use entity_access::domain::models::{};use entity_access_management::domain::models::EntityAccessManagementError;use entity_access_management::domain::ports::EntityAccessManagementService;+use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker, Topic as _};use macro_user_id::user_id::MacroUserIdStr;use model::document::{ContentType, DocumentMetadata, FileType};use model::folder::{@@ -27,9 +28,55 @@ use s3_key::BulkUploadStagingKey;use uuid::Uuid;use super::*;-use crate::domain::models::PurgedProjectTree;+use crate::domain::events::{ProjectCreatedMetadata, ProjectMacroEvent};+use crate::domain::models::{MarkedUploadedTree, PurgedProjectTree};use crate::domain::ports::MockProjectRepo;+/// A project lifecycle event recorded by [`TestEventBroker`].+#[derive(Clone, Debug)]+struct PublishedEvent {+ topic: &'static str,+ key: String,+ payload: serde_json::Value,+}++#[derive(Clone, Default)]+struct TestEventBroker {+ published: Arc<Mutex<Vec<PublishedEvent>>>,+ fail: bool,+}++impl TestEventBroker {+ fn failing() -> Self {+ Self {+ fail: true,+ ..Self::default()+ }+ }++ fn published(&self) -> Arc<Mutex<Vec<PublishedEvent>>> {+ Arc::clone(&self.published)+ }+}++impl MacroEventBroker for TestEventBroker {+ fn send_event<E: MacroEvent + ?Sized>(+ &self,+ event: &E,+ ) -> Result<tokio::task::JoinHandle<Result<(), EventBrokerError>>, EventBrokerError> {+ if self.fail {+ return Err(EventBrokerError::Publish("test failure".to_string()));+ }++ self.published.lock().unwrap().push(PublishedEvent {+ topic: event.topic().as_str(),+ key: event.key().to_string(),+ payload: serde_json::to_value(event.event())?,+ });+ Ok(tokio::spawn(async { Ok(()) }))+ }+}+#[derive(Clone, Copy)]struct NullPort;@@ -233,6 +280,24 @@ fn mutation_service(NullPort,RecordingEam,RecordingIndexer,+ TestEventBroker,+> {+ mutation_service_with_event_broker(repo, eam, indexer, TestEventBroker::default())+}++fn mutation_service_with_event_broker(+ repo: MockProjectRepo,+ eam: RecordingEam,+ indexer: RecordingIndexer,+ event_broker: TestEventBroker,+) -> ProjectServiceImpl<+ MockProjectRepo,+ NullPort,+ RecordingBulkUpload,+ NullPort,+ RecordingEam,+ RecordingIndexer,+ TestEventBroker,> {ProjectServiceImpl::new(repo,@@ -242,6 +307,7 @@ fn mutation_service(eam,indexer,None,+ event_broker,)}@@ -286,7 +352,17 @@ impl BulkUploadRequestPort for RecordingBulkUpload {fn service<D: BulkUploadRequestPort>(repo: MockProjectRepo,bulk_upload_service: D,-) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort> {+) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort, TestEventBroker>+{+ service_with_event_broker(repo, bulk_upload_service, TestEventBroker::default())+}++fn service_with_event_broker<D: BulkUploadRequestPort>(+ repo: MockProjectRepo,+ bulk_upload_service: D,+ event_broker: TestEventBroker,+) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort, TestEventBroker>+{ProjectServiceImpl::new(repo,NullPort,@@ -295,6 +371,7 @@ fn service<D: BulkUploadRequestPort>(NullPort,NullPort,None,+ event_broker,)}@@ -302,6 +379,73 @@ fn user_id(value: &str) -> MacroUserIdStr<'static> {MacroUserIdStr::try_from(value.to_string()).unwrap()}+#[test]+fn event_actor_user_id_only_maps_authenticated_users() {+ let user_id = user_id("macro|[email protected]");++ assert_eq!(+ event_actor_user_id(&EntityAccessAuth::Authenticated(user_id.clone())),+ Some(user_id)+ );+ assert_eq!(+ event_actor_user_id(&EntityAccessAuth::Unauthenticated),+ None+ );+ assert_eq!(event_actor_user_id(&EntityAccessAuth::Internal), None);+}++#[tokio::test]+async fn publish_project_event_records_the_serialized_envelope() {+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(+ MockProjectRepo::new(),+ RecordingBulkUpload::default(),+ event_broker,+ );+ let event = ProjectMacroEvent::created(+ "project-id",+ ProjectCreatedMetadata {+ project_id: "project-id".to_string(),+ owner: user_id("macro|[email protected]"),+ name: "Project".to_string(),+ parent_project_id: None,+ created_at: None,+ },+ );++ service.publish_project_event(&event);++ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_eq!(published[0].topic, "macro.projects");+ assert_eq!(published[0].key, "project-id");+ assert_eq!(published[0].payload["schema_version"], 1);+ assert_eq!(published[0].payload["event_type"], "project.created");+ assert_eq!(published[0].payload["metadata"]["name"], "Project");+}++#[test]+fn publish_project_event_errors_are_non_fatal() {+ let service = service_with_event_broker(+ MockProjectRepo::new(),+ RecordingBulkUpload::default(),+ TestEventBroker::failing(),+ );+ let event = ProjectMacroEvent::created(+ "project-id",+ ProjectCreatedMetadata {+ project_id: "project-id".to_string(),+ owner: user_id("macro|[email protected]"),+ name: "Project".to_string(),+ parent_project_id: None,+ created_at: None,+ },+ );++ service.publish_project_event(&event);+}+fn project(id: &str, owner: &str, parent_id: Option<&str>) -> Project {Project {id: id.to_string(),@@ -343,8 +487,23 @@ fn mutation_receipt<T>(project_id: Uuid, access_level: AccessLevel) -> EntityAccwhereT: entity_access::domain::models::RequiredPermission,{- EntityAccessReceipt::try_new(+ mutation_receipt_with_auth(+ project_id,+ access_level,EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),+ )+}++fn mutation_receipt_with_auth<T>(+ project_id: Uuid,+ access_level: AccessLevel,+ auth: EntityAccessAuth,+) -> EntityAccessReceipt<T>+where+ T: entity_access::domain::models::RequiredPermission,+{+ EntityAccessReceipt::try_new(+ auth,Entity {entity_id: project_id.to_string(),entity_type: EntityType::Project,@@ -354,6 +513,14 @@ where.unwrap()}+fn assert_project_event(event: &PublishedEvent, key: Uuid, event_type: &str) {+ assert_eq!(event.topic, "macro.projects");+ assert_eq!(event.key, key.to_string());+ assert!(Uuid::parse_str(event.payload["event_id"].as_str().unwrap()).is_ok());+ assert_eq!(event.payload["schema_version"], 1);+ assert_eq!(event.payload["event_type"], event_type);+}+fn patch_request(parent_id: Option<String>,share_permission: Option<UpdateSharePermissionRequestV2>,@@ -576,6 +743,248 @@ async fn create_uses_grapheme_limit_and_orchestrates_parent_side_effects() {);}+#[tokio::test]+async fn create_project_publishes_repository_metadata_after_success() {+ let project_id = Uuid::new_v4();+ let parent_id = Uuid::new_v4();+ let created_at = chrono::Utc::now();+ let expected_created_at = serde_json::to_value(created_at).unwrap();+ let mut repo = MockProjectRepo::new();+ repo.expect_create_project().return_once(move |_| {+ Box::pin(async move {+ let mut created = project(+ &project_id.to_string(),+ "ignored-repository-owner",+ Some(&parent_id.to_string()),+ );+ created.name = "Repository name".to_string();+ created.created_at = Some(created_at);+ Ok(created)+ })+ });+ repo.expect_update_project_modified()+ .return_once(|_| Box::pin(async { Ok(()) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ event_broker,+ );++ let result = service+ .create_project(+ user_id("macro|[email protected]"),+ CreateProjectRequest {+ name: "Requested name".to_string(),+ project_parent_id: Some(parent_id),+ },+ )+ .await+ .unwrap();++ assert_eq!(result.name, "Repository name");+ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_eq!(published[0].topic, "macro.projects");+ assert_eq!(published[0].key, project_id.to_string());+ let metadata = &published[0].payload["metadata"];+ assert_eq!(metadata["project_id"], project_id.to_string());+ assert_eq!(metadata["owner"], "macro|[email protected]");+ assert_eq!(metadata["name"], "Repository name");+ assert_eq!(metadata["parent_project_id"], parent_id.to_string());+ assert_eq!(metadata["created_at"], expected_created_at);+}++#[tokio::test]+async fn create_project_failures_publish_no_event() {+ let mut repo = MockProjectRepo::new();+ repo.expect_create_project()+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ event_broker,+ );++ let validation_error = service+ .create_project(+ user_id("macro|[email protected]"),+ CreateProjectRequest {+ name: "x".repeat(101),+ project_parent_id: None,+ },+ )+ .await;+ let repository_error = service+ .create_project(+ user_id("macro|[email protected]"),+ CreateProjectRequest {+ name: "Project".to_string(),+ project_parent_id: None,+ },+ )+ .await;++ assert!(validation_error.is_err());+ assert!(repository_error.is_err());+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn create_project_succeeds_when_event_publication_fails() {+ let project_id = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ repo.expect_create_project().return_once(move |_| {+ Box::pin(async move {+ Ok(project(+ &project_id.to_string(),+ "macro|[email protected]",+ None,+ ))+ })+ });+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ TestEventBroker::failing(),+ );++ let result = service+ .create_project(+ user_id("macro|[email protected]"),+ CreateProjectRequest {+ name: "Project".to_string(),+ project_parent_id: None,+ },+ )+ .await+ .unwrap();++ assert_eq!(result.id, project_id.to_string());+}++#[tokio::test]+async fn edit_project_publishes_requested_update_metadata() {+ struct Case {+ name: Option<&'static str>,+ old_parent: Option<Uuid>,+ requested_parent: Option<String>,+ sharing: bool,+ }++ let cases = [+ Case {+ name: Some("Renamed"),+ old_parent: None,+ requested_parent: None,+ sharing: false,+ },+ Case {+ name: None,+ old_parent: None,+ requested_parent: Some(Uuid::new_v4().to_string()),+ sharing: false,+ },+ Case {+ name: None,+ old_parent: Some(Uuid::new_v4()),+ requested_parent: Some(String::new()),+ sharing: false,+ },+ Case {+ name: None,+ old_parent: None,+ requested_parent: None,+ sharing: true,+ },+ Case {+ name: Some("Combined"),+ old_parent: Some(Uuid::new_v4()),+ requested_parent: Some(Uuid::new_v4().to_string()),+ sharing: true,+ },+ ];++ for case in cases {+ let project_id = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ if case+ .requested_parent+ .as_deref()+ .is_some_and(|parent| !parent.is_empty())+ {+ repo.expect_is_project_recursively_nested()+ .return_once(|_, _| Box::pin(async { Ok(false) }));+ }+ repo.expect_edit_project().return_once(move |_| {+ Box::pin(async move {+ Ok(project(+ &project_id.to_string(),+ "macro|[email protected]",+ None,+ ))+ })+ });+ let bump_count = 1+ + usize::from(case.old_parent.is_some())+ + usize::from(+ case.requested_parent+ .as_deref()+ .is_some_and(|parent| !parent.is_empty()),+ );+ repo.expect_update_project_modified()+ .times(bump_count)+ .returning(|_| Box::pin(async { Ok(()) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ event_broker,+ );+ let mut request = patch_request(+ case.requested_parent.clone(),+ case.sharing.then(share_update),+ );+ request.name = case.name.map(str::to_string);++ service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, case.old_parent, false),+ request,+ )+ .await+ .unwrap();++ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_eq!(published[0].key, project_id.to_string());+ assert_eq!(published[0].payload["event_type"], "project.updated");+ let metadata = &published[0].payload["metadata"];+ assert_eq!(metadata["project_id"], project_id.to_string());+ assert_eq!(metadata["owner"], "macro|[email protected]");+ assert_eq!(metadata["actor_user_id"], "macro|[email protected]");+ assert_eq!(metadata["name"], serde_json::json!(case.name));+ assert_eq!(+ metadata["previous_parent_id"],+ serde_json::json!(case.old_parent.map(|id| id.to_string()))+ );+ assert_eq!(+ metadata["parent_id"],+ serde_json::json!(case.requested_parent)+ );+ assert_eq!(metadata["share_permission_updated"], case.sharing);+ }+}+#[tokio::test]async fn edit_requires_owner_for_moves_and_share_changes() {let project_id = Uuid::new_v4();@@ -661,6 +1070,102 @@ async fn edit_rejects_deleted_self_recursive_and_invalid_parents() {assert!(matches!(recursive, ProjectError::RecursiveNesting));}+#[tokio::test]+async fn edit_project_failures_publish_no_event() {+ let project_id = Uuid::new_v4();+ let recursive_parent = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ repo.expect_is_project_recursively_nested()+ .return_once(|_, _| Box::pin(async { Ok(true) }));+ repo.expect_edit_project()+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ event_broker,+ );++ let mut invalid_name = patch_request(None, None);+ invalid_name.name = Some("x".repeat(101));+ let validation_error = service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),+ basic_project(project_id, None, false),+ invalid_name,+ )+ .await;+ let authorization_error = service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),+ basic_project(project_id, None, false),+ patch_request(Some(Uuid::new_v4().to_string()), None),+ )+ .await;+ let recursive_error = service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, false),+ patch_request(Some(recursive_parent.to_string()), None),+ )+ .await;+ let mut rename = patch_request(None, None);+ rename.name = Some("Renamed".to_string());+ let repository_error = service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),+ basic_project(project_id, None, false),+ rename,+ )+ .await;++ assert!(validation_error.is_err());+ assert!(authorization_error.is_err());+ assert!(matches!(+ recursive_error,+ Err(ProjectError::RecursiveNesting)+ ));+ assert!(repository_error.is_err());+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn edit_project_succeeds_when_event_publication_fails() {+ let project_id = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ repo.expect_edit_project().return_once(move |_| {+ Box::pin(async move {+ Ok(project(+ &project_id.to_string(),+ "macro|[email protected]",+ None,+ ))+ })+ });+ repo.expect_update_project_modified()+ .return_once(|_| Box::pin(async { Ok(()) }));+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ TestEventBroker::failing(),+ );+ let mut request = patch_request(None, None);+ request.name = Some("Renamed".to_string());++ let result = service+ .edit_project(+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),+ basic_project(project_id, None, false),+ request,+ )+ .await;++ assert!(result.is_ok());+}+#[tokio::test]async fn owner_edit_propagates_move_and_pairs_every_bump_with_an_upsert() {let project_id = Uuid::new_v4();@@ -846,13 +1351,16 @@ async fn soft_delete_removes_index_entries_and_bumps_parent_with_upsert() {.return_once(|_| Box::pin(async { Ok(()) }));let indexer = RecordingIndexer::default();let calls = indexer.calls.clone();- let service = mutation_service(repo, RecordingEam::default(), indexer);+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service =+ mutation_service_with_event_broker(repo, RecordingEam::default(), indexer, event_broker);service.soft_delete_project(mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),basic_project(project_id, Some(parent_id), false),- "macro|[email protected]".to_string(),+ "unused-actor".to_string(),).await.unwrap();@@ -860,10 +1368,27 @@ async fn soft_delete_removes_index_entries_and_bumps_parent_with_upsert() {assert_eq!(*calls.lock().unwrap(),vec![- IndexCall::Remove(expected_deleted_ids),+ IndexCall::Remove(expected_deleted_ids.clone()),IndexCall::Upsert(vec![parent_id.to_string()]),]);+ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_project_event(&published[0], project_id, "project.deleted");+ let metadata = &published[0].payload["metadata"];+ assert_eq!(metadata["project_id"], project_id.to_string());+ assert_eq!(metadata["owner"], "macro|[email protected]");+ assert_eq!(metadata["actor_user_id"], "macro|[email protected]");+ assert_eq!(metadata["parent_project_id"], parent_id.to_string());+ assert_eq!(+ metadata["deleted_project_ids"],+ serde_json::json!(expected_deleted_ids)+ );+ assert_eq!(+ metadata["deleted_document_ids"],+ serde_json::json!(["document"])+ );+ assert_eq!(metadata["deleted_chat_ids"], serde_json::json!(["chat"]));}#[tokio::test]@@ -887,11 +1412,18 @@ async fn revert_upserts_every_restored_project() {});let indexer = RecordingIndexer::default();let calls = indexer.calls.clone();- let service = mutation_service(repo, RecordingEam::default(), indexer);+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service =+ mutation_service_with_event_broker(repo, RecordingEam::default(), indexer, event_broker);service.revert_delete_project(- mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ mutation_receipt_with_auth::<OwnerAccessLevel>(+ project_id,+ AccessLevel::Owner,+ EntityAccessAuth::Internal,+ ),basic_project(project_id, Some(parent_id), true),).await@@ -899,8 +1431,87 @@ async fn revert_upserts_every_restored_project() {assert_eq!(*calls.lock().unwrap(),- vec![IndexCall::Upsert(expected_ids)]+ vec![IndexCall::Upsert(expected_ids.clone())]+ );+ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_project_event(&published[0], project_id, "project.restored");+ let metadata = &published[0].payload["metadata"];+ assert_eq!(metadata["project_id"], project_id.to_string());+ assert_eq!(metadata["owner"], "macro|[email protected]");+ assert!(metadata["actor_user_id"].is_null());+ assert_eq!(metadata["parent_project_id"], parent_id.to_string());+ assert_eq!(+ metadata["restored_project_ids"],+ serde_json::json!(expected_ids)+ );+}++#[tokio::test]+async fn deletion_repository_failures_publish_no_events() {+ let project_id = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ repo.expect_soft_delete_project()+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("delete failed")) }));+ repo.expect_revert_delete_project()+ .return_once(|_, _| Box::pin(async { Err(anyhow::anyhow!("restore failed")) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ event_broker,);++ let delete_result = service+ .soft_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, false),+ "unused".to_string(),+ )+ .await;+ let restore_result = service+ .revert_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, true),+ )+ .await;++ assert!(delete_result.is_err());+ assert!(restore_result.is_err());+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn soft_delete_succeeds_when_event_publication_fails() {+ let project_id = Uuid::new_v4();+ let mut repo = MockProjectRepo::new();+ repo.expect_soft_delete_project().return_once(move |_| {+ Box::pin(async move {+ Ok(SoftDeleteResult {+ project_ids: vec![project_id.to_string()],+ document_ids: Vec::new(),+ chat_ids: Vec::new(),+ })+ })+ });+ let service = mutation_service_with_event_broker(+ repo,+ RecordingEam::default(),+ RecordingIndexer::default(),+ TestEventBroker::failing(),+ );++ let result = service+ .soft_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, false),+ "unused".to_string(),+ )+ .await;++ assert!(result.is_ok());}#[tokio::test]@@ -933,6 +1544,15 @@ impl ShaCounterPort for OrderedSha {}}+#[derive(Clone, Copy)]+struct FailingSha;++impl ShaCounterPort for FailingSha {+ async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {+ anyhow::bail!("sha counter unavailable")+ }+}+#[derive(Clone)]struct OrderedIndexer {events: Arc<Mutex<Vec<&'static str>>>,@@ -1094,6 +1714,8 @@ async fn permanent_delete_runs_external_work_after_committed_purge() {})})});+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();let service = ProjectServiceImpl::new(repo,NullPort,@@ -1107,13 +1729,16 @@ async fn permanent_delete_runs_external_work_after_committed_purge() {fail: true,},None,+ event_broker,);+ let project_id = Uuid::new_v4();+ let parent_id = Uuid::new_v4();service- .permanently_delete_project(mutation_receipt::<OwnerAccessLevel>(- Uuid::new_v4(),- AccessLevel::Owner,- ))+ .permanently_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, Some(parent_id), true),+ ).await.unwrap();@@ -1128,6 +1753,23 @@ async fn permanent_delete_runs_external_work_after_committed_purge() {"document_deletes"]);+ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_project_event(&published[0], project_id, "project.permanently_deleted");+ let metadata = &published[0].payload["metadata"];+ assert_eq!(metadata["project_id"], project_id.to_string());+ assert_eq!(metadata["owner"], "macro|[email protected]");+ assert_eq!(metadata["actor_user_id"], "macro|[email protected]");+ assert_eq!(metadata["parent_project_id"], parent_id.to_string());+ assert_eq!(+ metadata["purged_project_ids"],+ serde_json::json!(["project"])+ );+ assert_eq!(+ metadata["purged_document_ids"],+ serde_json::json!(["document"])+ );+ assert_eq!(metadata["purged_chat_ids"], serde_json::json!(["chat"]));}#[tokio::test]@@ -1135,16 +1777,58 @@ async fn permanent_delete_has_no_external_side_effects_when_purge_fails() {let mut repo = MockProjectRepo::new();repo.expect_purge_deleted_project_tree().return_once(|_| Box::pin(async { Err(anyhow::anyhow!("commit failed")) }));- let service = service(repo, RecordingBulkUpload::default());+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);+ let project_id = Uuid::new_v4();let result = service- .permanently_delete_project(mutation_receipt::<OwnerAccessLevel>(- Uuid::new_v4(),- AccessLevel::Owner,- ))+ .permanently_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, true),+ ).await;assert!(result.is_err());+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn permanent_delete_sha_failure_publishes_no_event() {+ let mut repo = MockProjectRepo::new();+ repo.expect_purge_deleted_project_tree().return_once(|_| {+ Box::pin(async {+ Ok(PurgedProjectTree {+ project_ids: vec!["project".to_string()],+ chat_ids: Vec::new(),+ documents: Vec::new(),+ bom_shas: vec![("sha".to_string(), 1)],+ })+ })+ });+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = ProjectServiceImpl::new(+ repo,+ NullPort,+ RecordingBulkUpload::default(),+ FailingSha,+ NullPort,+ RecordingIndexer::default(),+ None,+ event_broker,+ );+ let project_id = Uuid::new_v4();++ let result = service+ .permanently_delete_project(+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),+ basic_project(project_id, None, true),+ )+ .await;++ assert!(result.is_err());+ assert!(published.lock().unwrap().is_empty());}#[tokio::test]@@ -1178,6 +1862,147 @@ async fn destination_maps_preserve_internal_external_and_docx_behavior() {assert!(!external.contains_key("docx"));}+#[tokio::test]+async fn mark_projects_uploaded_publishes_root_metadata_and_returns_subtree_ids() {+ let root_project_id = "root-project";+ let project_ids = vec![+ root_project_id.to_string(),+ "child-project".to_string(),+ "grandchild-project".to_string(),+ ];+ let expected_project_ids = project_ids.clone();+ let mut repo = MockProjectRepo::new();+ repo.expect_mark_projects_uploaded()+ .withf(move |id| id == root_project_id)+ .return_once(move |_| {+ Box::pin(async move {+ Ok(MarkedUploadedTree {+ id: root_project_id.to_string(),+ name: "Uploaded tree".to_string(),+ user_id: user_id("macro|[email protected]"),+ parent_id: Some("parent-project".to_string()),+ project_ids,+ upload_pending_transitioned: true,+ })+ })+ });+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);++ let result = service+ .mark_projects_uploaded(root_project_id)+ .await+ .unwrap();++ assert_eq!(result, expected_project_ids);+ let published = published.lock().unwrap();+ assert_eq!(published.len(), 1);+ assert_eq!(published[0].topic, "macro.projects");+ assert_eq!(published[0].key, root_project_id);+ assert_eq!(published[0].payload["schema_version"], 1);+ assert_eq!(published[0].payload["event_type"], "project.uploaded");+ assert_eq!(+ published[0].payload["metadata"],+ serde_json::json!({+ "root_project_id": root_project_id,+ "owner": "macro|[email protected]",+ "name": "Uploaded tree",+ "parent_project_id": "parent-project",+ "project_ids": expected_project_ids,+ })+ );+}++#[tokio::test]+async fn repeated_mark_projects_uploaded_returns_subtree_ids_without_publishing() {+ let project_ids = vec!["root-project".to_string(), "child-project".to_string()];+ let expected_project_ids = project_ids.clone();+ let mut repo = MockProjectRepo::new();+ repo.expect_mark_projects_uploaded().return_once(|_| {+ Box::pin(async move {+ Ok(MarkedUploadedTree {+ id: "root-project".to_string(),+ name: "Uploaded tree".to_string(),+ user_id: user_id("macro|[email protected]"),+ parent_id: None,+ project_ids,+ upload_pending_transitioned: false,+ })+ })+ });+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);++ let result = service+ .mark_projects_uploaded("root-project")+ .await+ .unwrap();++ assert_eq!(result, expected_project_ids);+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn mark_projects_uploaded_missing_root_publishes_no_event() {+ let mut repo = MockProjectRepo::new();+ repo.expect_mark_projects_uploaded()+ .return_once(|_| Box::pin(async { Err(anyhow::Error::new(sqlx::Error::RowNotFound)) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);++ let result = service.mark_projects_uploaded("missing-project").await;++ assert!(matches!(result, Err(ProjectError::Internal(_))));+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn mark_projects_uploaded_repository_failure_publishes_no_event() {+ let mut repo = MockProjectRepo::new();+ repo.expect_mark_projects_uploaded()+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));+ let event_broker = TestEventBroker::default();+ let published = event_broker.published();+ let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);++ let result = service.mark_projects_uploaded("root-project").await;++ assert!(matches!(result, Err(ProjectError::Internal(_))));+ assert!(published.lock().unwrap().is_empty());+}++#[tokio::test]+async fn mark_projects_uploaded_publication_failure_is_non_fatal() {+ let mut repo = MockProjectRepo::new();+ repo.expect_mark_projects_uploaded().return_once(|_| {+ Box::pin(async {+ Ok(MarkedUploadedTree {+ id: "root-project".to_string(),+ name: "Uploaded tree".to_string(),+ user_id: user_id("macro|[email protected]"),+ parent_id: None,+ project_ids: vec!["root-project".to_string(), "child-project".to_string()],+ upload_pending_transitioned: true,+ })+ })+ });+ let service = service_with_event_broker(+ repo,+ RecordingBulkUpload::default(),+ TestEventBroker::failing(),+ );++ let result = service+ .mark_projects_uploaded("root-project")+ .await+ .unwrap();++ assert_eq!(result, vec!["root-project", "child-project"]);+}+#[tokio::test]async fn upload_folder_compensates_after_destination_failure() {let mut repo = MockProjectRepo::new();@@ -1207,6 +2032,7 @@ async fn upload_folder_compensates_after_destination_failure() {NullPort,NullPort,None,+ TestEventBroker::default(),);let result = service@@ -1249,6 +2075,7 @@ async fn upload_extract_uses_fixed_request_id() {NullPort,NullPort,Some(fixed_id),+ TestEventBroker::default(),);let response = servicediff --git a/crates/projects/src/inbound/axum_router/delete_project.rs b/crates/projects/src/inbound/axum_router/delete_project.rsindex 337ead69d8..0048010526 100644--- a/crates/projects/src/inbound/axum_router/delete_project.rs+++ b/crates/projects/src/inbound/axum_router/delete_project.rs@@ -85,11 +85,12 @@ where(status = 500, body = model::response::GenericErrorResponse),))]-#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]+#[tracing::instrument(skip(state, user, access, project), fields(user_id=?user.macro_user_id), err)]pub async fn permanently_delete_project_handler<T, Svc, Auth>(State(state): State<ProjectRouterState<T, Svc, Auth>>,user: MacroAuthorizationExtractor<Auth>,access: ProjectAccessLevelExtractor<OwnerAccessLevel, Svc, Auth>,+ Extension(project): Extension<BasicProject>,) -> Result<Json<SuccessResponse>, ProjectError>whereT: ProjectService,@@ -98,7 +99,7 @@ where{state.service- .permanently_delete_project(access.entity_access_receipt)+ .permanently_delete_project(access.entity_access_receipt, project).await?;Ok(Json(SuccessResponse {diff --git a/crates/projects/src/inbound/axum_router/tests.rs b/crates/projects/src/inbound/axum_router/tests.rsindex 6122acd4eb..3f785ea2ee 100644--- a/crates/projects/src/inbound/axum_router/tests.rs+++ b/crates/projects/src/inbound/axum_router/tests.rs@@ -55,6 +55,7 @@ const PROJECT_ID: &str = "project-1";struct FakeProjectService {basic_project: Arc<Mutex<Result<BasicProject, String>>>,mutations: Arc<Mutex<Vec<&'static str>>>,+ permanently_deleted_projects: Arc<Mutex<Vec<BasicProject>>>,upload_internal_flags: Arc<Mutex<Vec<bool>>>,}@@ -69,6 +70,7 @@ impl FakeProjectService {deleted_at: deleted.then(chrono::Utc::now),}))),mutations: Arc::new(Mutex::new(Vec::new())),+ permanently_deleted_projects: Arc::new(Mutex::new(Vec::new())),upload_internal_flags: Arc::new(Mutex::new(Vec::new())),}}@@ -77,6 +79,7 @@ impl FakeProjectService {Self {basic_project: Arc::new(Mutex::new(Err("missing".to_string()))),mutations: Arc::new(Mutex::new(Vec::new())),+ permanently_deleted_projects: Arc::new(Mutex::new(Vec::new())),upload_internal_flags: Arc::new(Mutex::new(Vec::new())),}}@@ -176,11 +179,16 @@ impl ProjectService for FakeProjectService {async fn permanently_delete_project(&self,_receipt: EntityAccessReceipt<entity_access::domain::models::OwnerAccessLevel>,+ project: BasicProject,) -> Result<(), ProjectError> {self.mutations.lock().expect("mutation lock poisoned").push("permanent_delete");+ self.permanently_deleted_projects+ .lock()+ .expect("permanently deleted project lock poisoned")+ .push(project);Ok(())}@@ -811,6 +819,36 @@ async fn internal_upload_selects_internal_destinations_with_exact_lambda_json());}+#[tokio::test]+async fn permanent_delete_forwards_loaded_project() {+ let service = FakeProjectService::with_project(USER_ID, true);+ let expected_project = service+ .basic_project+ .lock()+ .expect("basic project lock poisoned")+ .as_ref()+ .expect("project should exist")+ .clone();+ let deleted_projects = service.permanently_deleted_projects.clone();+ let response = router(service, Some(AccessLevel::Owner))+ .oneshot(+ Request::delete(format!("/{PROJECT_ID}/permanent"))+ .header("authorization", format!("Bearer {TOKEN}"))+ .body(Body::empty())+ .expect("request should be valid"),+ )+ .await+ .expect("router should respond");++ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(+ *deleted_projects+ .lock()+ .expect("permanently deleted project lock poisoned"),+ vec![expected_project]+ );+}+#[tokio::test]async fn permanent_delete_requires_owner_access() {let service = FakeProjectService::with_project("macro|[email protected]", true);diff --git a/crates/projects/src/outbound/pg_project_repo.rs b/crates/projects/src/outbound/pg_project_repo.rsindex f59c2e781e..bea0d2c163 100644--- a/crates/projects/src/outbound/pg_project_repo.rs+++ b/crates/projects/src/outbound/pg_project_repo.rs@@ -21,8 +21,8 @@ use model::project::{use sqlx::PgPool;use crate::domain::models::{- CreateProjectArgs, EditProjectArgs, PurgedProjectTree, RevertDeleteResult, SoftDeleteResult,- UploadFolderRepoArgs,+ CreateProjectArgs, EditProjectArgs, MarkedUploadedTree, PurgedProjectTree, RevertDeleteResult,+ SoftDeleteResult, UploadFolderRepoArgs,};use crate::domain::ports::ProjectRepo;@@ -325,12 +325,12 @@ impl ProjectRepo for PgProjectRepo {async fn mark_projects_uploaded(&self,root_project_id: &str,- ) -> Result<Vec<String>, Self::Err> {+ ) -> Result<MarkedUploadedTree, Self::Err> {let mut transaction = self.pool.begin().await?;- let project_ids =+ let uploaded_tree =upload_folder::mark_projects_uploaded(&mut transaction, root_project_id).await?;transaction.commit().await?;- Ok(project_ids)+ Ok(uploaded_tree)}#[tracing::instrument(err, skip(self))]diff --git a/crates/projects/src/outbound/pg_project_repo/tests.rs b/crates/projects/src/outbound/pg_project_repo/tests.rsindex 03f7c048f7..c1d28be56f 100644--- a/crates/projects/src/outbound/pg_project_repo/tests.rs+++ b/crates/projects/src/outbound/pg_project_repo/tests.rs@@ -528,10 +528,24 @@ async fn mark_uploaded_is_recursive_and_rejects_missing_root(pool: Pool<Postgres>,) -> anyhow::Result<()> {let repo = PgProjectRepo::new(pool.clone());- let project_ids = repo+ let uploaded_tree = repo.mark_projects_uploaded("10000000-0000-0000-0000-000000000006").await?;- assert_eq!(project_ids.len(), 2);+ assert_eq!(uploaded_tree.id, "10000000-0000-0000-0000-000000000006");+ assert_eq!(uploaded_tree.name, "Owner pending");+ assert_eq!(uploaded_tree.user_id.as_ref(), "macro|[email protected]");+ assert_eq!(uploaded_tree.parent_id, None);+ assert!(uploaded_tree.upload_pending_transitioned);++ let mut project_ids = uploaded_tree.project_ids;+ project_ids.sort();+ assert_eq!(+ project_ids,+ [+ "10000000-0000-0000-0000-000000000006".to_owned(),+ "10000000-0000-0000-0000-000000000008".to_owned(),+ ]+ );let pending = sqlx::query_scalar!(r#"SELECT COUNT(*) AS "count!" FROM "Project" WHERE id = ANY($1) AND "uploadPending""#,&project_ids,@@ -539,6 +553,16 @@ async fn mark_uploaded_is_recursive_and_rejects_missing_root(.fetch_one(&pool).await?;assert_eq!(pending, 0);- assert!(repo.mark_projects_uploaded("missing").await.is_err());++ let repeated = repo+ .mark_projects_uploaded("10000000-0000-0000-0000-000000000006")+ .await?;+ assert!(!repeated.upload_pending_transitioned);+ let mut repeated_project_ids = repeated.project_ids;+ repeated_project_ids.sort();+ assert_eq!(repeated_project_ids, project_ids);++ let missing_error = repo.mark_projects_uploaded("missing").await.unwrap_err();+ assert!(matches!(missing_error, sqlx::Error::RowNotFound));Ok(())}diff --git a/crates/projects/src/outbound/pg_project_repo/upload_folder.rs b/crates/projects/src/outbound/pg_project_repo/upload_folder.rsindex 23c41a3c77..8e13866421 100644--- a/crates/projects/src/outbound/pg_project_repo/upload_folder.rs+++ b/crates/projects/src/outbound/pg_project_repo/upload_folder.rs@@ -11,7 +11,7 @@ use model::project::Project;use models_permissions::share_permission::SharePermissionV2;use sqlx::{Postgres, Transaction};-use crate::domain::models::UploadFolderRepoArgs;+use crate::domain::models::{MarkedUploadedTree, UploadFolderRepoArgs};use super::share;@@ -339,8 +339,8 @@ async fn insert_tree_history(pub(super) async fn mark_projects_uploaded(transaction: &mut Transaction<'_, Postgres>,root_project_id: &str,-) -> Result<Vec<String>, sqlx::Error> {- let project_ids = sqlx::query_scalar!(+) -> Result<MarkedUploadedTree, sqlx::Error> {+ let rows = sqlx::query!(r#"WITH RECURSIVE project_hierarchy AS (SELECT id FROM "Project" WHERE id = $1@@ -348,18 +348,48 @@ pub(super) async fn mark_projects_uploaded(SELECT child.idFROM "Project" childJOIN project_hierarchy parent ON child."parentId" = parent.id+ ),+ updated_projects AS (+ UPDATE "Project"+ SET "uploadPending" = false+ WHERE id IN (SELECT id FROM project_hierarchy)+ AND "uploadPending" = true+ RETURNING id)- UPDATE "Project"- SET "uploadPending" = false- WHERE id IN (SELECT id FROM project_hierarchy)- RETURNING id+ SELECT+ project.id,+ project.name,+ project."userId" AS user_id,+ project."parentId" AS parent_id,+ EXISTS (+ SELECT 1 FROM updated_projects WHERE id = $1+ ) AS "upload_pending_transitioned!"+ FROM "Project" project+ JOIN project_hierarchy hierarchy ON hierarchy.id = project.id"#,root_project_id,).fetch_all(transaction.as_mut()).await?;- if project_ids.is_empty() {+ if rows.is_empty() {return Err(sqlx::Error::RowNotFound);}- Ok(project_ids)++ let root = rows+ .iter()+ .find(|row| row.id == root_project_id)+ .ok_or_else(|| {+ sqlx::Error::Protocol("updated project tree did not include its root".to_owned())+ })?;+ let user_id = MacroUserIdStr::try_from(root.user_id.clone())+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?;++ Ok(MarkedUploadedTree {+ id: root.id.clone(),+ name: root.name.clone(),+ user_id,+ parent_id: root.parent_id.clone(),+ upload_pending_transitioned: root.upload_pending_transitioned,+ project_ids: rows.into_iter().map(|row| row.id).collect(),+ })}diff --git a/deny.toml b/deny.tomlindex 5300bd9fe3..ac10ece054 100644--- a/deny.toml+++ b/deny.toml@@ -199,15 +199,16 @@ deny = ["documents", # Dev logging only"email", # Dev logging only"lambda_runtime_api_client", # External crate allowed to use tracing-subscriber+ "loom", # External concurrency testing dependency"macro_entrypoint","native_app_server", # Dev tooling only"notification_sandbox", # This is not production code its just tooling+ "projects", # Dev logging only"sync_service", # Cloudflare/WASM tracing setup uses tracing-web- "tracing-web", # External WASM tracing layer- "loom", # External concurrency testing dependency"tracing-opentelemetry", # OpenTelemetry integration requires tracing-subscriber"tracing-panic", # External crate allowed to use tracing-subscriber"tracing-tree",+ "tracing-web", # External WASM tracing layer], reason = "Use macro_entrypoint for tracing setup in workspace crates" },]diff --git a/services/document_storage_service/src/api/context.rs b/services/document_storage_service/src/api/context.rsindex 9628038f98..3aba0be10c 100644--- a/services/document_storage_service/src/api/context.rs+++ b/services/document_storage_service/src/api/context.rs@@ -266,6 +266,7 @@ pub(crate) type ProjectService = ProjectServiceImpl<ShaCountAdapter,EntityAccessManagementService,SqsProjectSearchIndexer,+ MacroEventBrokerService<KafkaEventPublisher>,>;/// Type alias for the projects router state.diff --git a/services/document_storage_service/src/main.rs b/services/document_storage_service/src/main.rsindex 6ece836b82..0d4eaddc39 100644--- a/services/document_storage_service/src/main.rs+++ b/services/document_storage_service/src/main.rs@@ -442,6 +442,7 @@ async fn main() -> anyhow::Result<()> {} else {None},+ macro_event_broker.clone(),));let document_service = Arc::new(