Skip to content

armgit / macro

Public Imported from GitHub
0

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

feat(projects): kafka projects producer (#4968)

Will Hutchinson35f25cf35cbc
diff --git a/.github/kafka-cluster-topics.json b/.github/kafka-cluster-topics.json
index 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.json
deleted file mode 100644
index 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.json
new file mode 100644
index 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.lock
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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>
where
R: ProjectRepo,
U: ProjectUploadUrlPort,
@@ -47,6 +64,7 @@ where
Sha: ShaCounterPort,
Eam: EntityAccessManagementService,
Idx: ProjectSearchIndexer,
+ B: MacroEventBroker,
{
/// Project repository.
pub repo: R,
@@ -60,11 +78,13 @@ where
pub 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>
where
R: ProjectRepo,
U: ProjectUploadUrlPort,
@@ -72,6 +92,7 @@ where
Sha: 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 @@ where
entity_access_management_service: Eam,
search_indexer: Idx,
fixed_upload_request_id: Option<Uuid>,
+ macro_event_broker: B,
) -> Self {
Self {
repo,
@@ -91,10 +113,21 @@ where
sha_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>
where
R: ProjectRepo,
U: ProjectUploadUrlPort,
@@ -129,6 +162,7 @@ where
Sha: ShaCounterPort,
Eam: EntityAccessManagementService,
Idx: ProjectSearchIndexer,
+ B: MacroEventBroker,
{
async fn list_projects(
&self,
@@ -334,6 +368,17 @@ where
self.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 @@ where
validate_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 @@ where
self.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 @@ where
self.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 @@ where
receipt: 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.rs
index 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) -> EntityAcc
where
T: 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(),
+ 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(),
+ 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(),
+ 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 = service
diff --git a/crates/projects/src/inbound/axum_router/delete_project.rs b/crates/projects/src/inbound/axum_router/delete_project.rs
index 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>
where
T: 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.id
FROM "Project" child
JOIN 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.toml
index 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.rs
index 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.rs
index 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(