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.

fix(contacts): preserve explicit email contact relationships (#4950)

Evan Hutnike538c3fbd913
diff --git a/.sqlx/query-beeb3f92cd18664a6d748be12f52f8051602e6d2aaf7d5194af235e77902265b.json b/.sqlx/query-beeb3f92cd18664a6d748be12f52f8051602e6d2aaf7d5194af235e77902265b.json
index 2f9e8ba545..2fc35ddbb8 100644
--- a/.sqlx/query-beeb3f92cd18664a6d748be12f52f8051602e6d2aaf7d5194af235e77902265b.json
+++ b/.sqlx/query-beeb3f92cd18664a6d748be12f52f8051602e6d2aaf7d5194af235e77902265b.json
@@ -26,7 +26,7 @@
]
},
"nullable": [
- true,
+ null,
null,
null
]
diff --git a/CLAUDE.md b/CLAUDE.md
index ffc2c23435..3168703311 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -56,7 +56,8 @@ camelCased rather than snake_cased (use `/dump-schema` or check the migration fi
When a column is camelCased, you need to cast it as the snake_cased version when reading from the database. E.g.
`SELECT "userId" as "user_id" FROM "UserInsights"`.
Any time you make changes to the SQL code in rust, you need to run `just prepare_db` to
-update the `.sqlx` directory. Run it **only** from the repository root — do not run it from
+update the `.sqlx` directory. Always run it inside `nix develop` and **only** from the
+repository root (for example, `nix develop --command just prepare_db`) — do not run it from
individual crate directories anymore. The workspace-level recipe handles every crate that
has sqlx queries.
diff --git a/crates/contacts/src/domain/models/messages.rs b/crates/contacts/src/domain/models/messages.rs
index 4946cbe141..6e81324ff6 100644
--- a/crates/contacts/src/domain/models/messages.rs
+++ b/crates/contacts/src/domain/models/messages.rs
@@ -2,9 +2,55 @@ use macro_user_id::user_id::MacroUserIdStr;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
-/// A contacts SQS message carrying the list of user IDs to connect.
+#[cfg(test)]
+mod test;
+
+/// A contacts SQS message carrying the list of user IDs to connect. All users in the set will
+/// get connected with all other users in the set.
#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
pub struct ContactsNodes {
/// User IDs whose pairwise connections should be upserted.
pub users: HashSet<MacroUserIdStr<'static>>,
}
+
+/// An explicit undirected relationship between two contacts users.
+#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub struct ContactConnection {
+ /// One endpoint of the relationship.
+ pub first: MacroUserIdStr<'static>,
+ /// The other endpoint of the relationship.
+ pub second: MacroUserIdStr<'static>,
+}
+
+impl ContactConnection {
+ /// Creates an explicit relationship between two users.
+ pub fn new(first: MacroUserIdStr<'static>, second: MacroUserIdStr<'static>) -> Self {
+ Self { first, second }
+ }
+}
+
+/// A contacts SQS message carrying only explicitly requested relationships.
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ContactConnections {
+ /// Relationships to upsert.
+ pub connections: Vec<ContactConnection>,
+}
+
+impl ContactConnections {
+ /// Creates an explicit-relationships message.
+ pub fn new(connections: Vec<ContactConnection>) -> Self {
+ Self { connections }
+ }
+}
+
+/// A message accepted by the contacts queue consumer.
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum ContactsMessage {
+ /// The existing complete-graph message.
+ Nodes(ContactsNodes),
+ /// A message containing explicit relationships.
+ Connections(ContactConnections),
+}
diff --git a/crates/contacts/src/domain/models/messages/test.rs b/crates/contacts/src/domain/models/messages/test.rs
new file mode 100644
index 0000000000..66e1212453
--- /dev/null
+++ b/crates/contacts/src/domain/models/messages/test.rs
@@ -0,0 +1,51 @@
+use super::*;
+
+fn user(email: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::try_from_email(email).unwrap()
+}
+
+#[test]
+fn explicit_connections_are_a_separate_message_shape() {
+ let connections = vec![ContactConnection::new(
+ )];
+ let serialized = serde_json::to_value(ContactConnections::new(connections.clone())).unwrap();
+
+ assert!(serialized.get("users").is_none());
+ assert_eq!(
+ serde_json::from_value::<ContactConnections>(serialized)
+ .unwrap()
+ .connections,
+ connections
+ );
+}
+
+#[test]
+fn consumer_deserializes_existing_nodes_message() {
+ let message: ContactsMessage = serde_json::from_str(
+ r#"{"users":["macro|[email protected]","macro|[email protected]"]}"#,
+ )
+ .unwrap();
+
+ assert!(matches!(message, ContactsMessage::Nodes(_)));
+}
+
+#[test]
+fn consumer_rejects_message_with_both_shapes() {
+ let message = serde_json::from_str::<ContactsMessage>(
+ r#"{"users":["macro|[email protected]"],"connections":[]}"#,
+ );
+
+ assert!(message.is_err());
+}
+
+#[test]
+fn consumer_deserializes_explicit_connections_message() {
+ let message: ContactsMessage = serde_json::from_str(
+ r#"{"connections":[{"first":"macro|[email protected]","second":"macro|[email protected]"}]}"#,
+ )
+ .unwrap();
+
+ assert!(matches!(message, ContactsMessage::Connections(_)));
+}
diff --git a/crates/contacts/src/domain/ports.rs b/crates/contacts/src/domain/ports.rs
index 0438b72c9d..8a4afcb91d 100644
--- a/crates/contacts/src/domain/ports.rs
+++ b/crates/contacts/src/domain/ports.rs
@@ -1,4 +1,4 @@
-use crate::domain::models::messages::ContactsNodes;
+use crate::domain::models::messages::{ContactConnection, ContactConnections, ContactsNodes};
use macro_user_id::user_id::MacroUserIdStr;
use rootcause::Report;
use sqlx::types::Uuid;
@@ -30,8 +30,17 @@ pub trait ContactsNotifier: Send + Sync + 'static {
/// Port trait for publishing a contacts message to the ingress queue.
pub trait ContactsIngressQueue: Send + Sync + 'static {
- /// Publish a contacts message to the queue.
- fn publish(&self, message: ContactsNodes) -> impl Future<Output = Result<(), Report>> + Send;
+ /// Publishes a complete-graph contacts message to the queue.
+ fn publish_nodes(
+ &self,
+ message: ContactsNodes,
+ ) -> impl Future<Output = Result<(), Report>> + Send;
+
+ /// Publishes explicit contact relationships to the queue.
+ fn publish_connections(
+ &self,
+ message: ContactConnections,
+ ) -> impl Future<Output = Result<(), Report>> + Send;
}
/// Port trait for enqueuing contacts messages for async processing.
@@ -41,6 +50,12 @@ pub trait ContactsIngress: Send + Sync + 'static {
&self,
users: HashSet<MacroUserIdStr<'static>>,
) -> impl Future<Output = Result<(), Report>> + Send;
+
+ /// Enqueues only the supplied contact relationships for upsert.
+ fn enqueue_contact_connections(
+ &self,
+ connections: Vec<ContactConnection>,
+ ) -> impl Future<Output = Result<(), Report>> + Send;
}
/// Trait for contacts service operations
diff --git a/crates/contacts/src/domain/service.rs b/crates/contacts/src/domain/service.rs
index da131a91ac..980677b282 100644
--- a/crates/contacts/src/domain/service.rs
+++ b/crates/contacts/src/domain/service.rs
@@ -1,5 +1,7 @@
use crate::domain::models::graph::{UndirectedGraph, Vertex};
-use crate::domain::models::messages::ContactsNodes;
+use crate::domain::models::messages::{
+ ContactConnection, ContactConnections, ContactsMessage, ContactsNodes,
+};
use crate::domain::ports::{
ContactsBackfillOutboxRepo, ContactsIngress, ContactsIngressQueue, ContactsNotifier,
ContactsOutboxService, ContactsRepository, ContactsService,
@@ -36,26 +38,41 @@ impl<R: ContactsRepository, N: ContactsNotifier> ContactsDomainService<R, N> {
Ok(res)
}
- /// Processes a contacts SQS message by computing all pairwise connections
- /// from the user list and persisting them.
+ /// Processes either the existing complete-graph message or a separate
+ /// explicit-relationships message.
#[instrument(err, skip(self))]
pub(crate) async fn process_message(
&self,
- msg: ContactsNodes,
+ msg: ContactsMessage,
) -> Result<(), rootcause::Report> {
- let connections: Vec<(MacroUserIdStr<'static>, MacroUserIdStr<'static>)> = {
- let graph = UndirectedGraph::new(msg.users.iter().map(Vertex::new)).complete();
- graph
- .inner()
- .edges()
- .map(|e| (e.a().data().clone(), e.b().data().clone()))
- .collect()
+ let (users, connections) = match msg {
+ ContactsMessage::Nodes(ContactsNodes { users }) => {
+ let graph = UndirectedGraph::new(users.iter().map(Vertex::new)).complete();
+ let connections = graph
+ .inner()
+ .edges()
+ .map(|edge| (edge.a().data().clone(), edge.b().data().clone()))
+ .collect();
+ (users, connections)
+ }
+ ContactsMessage::Connections(ContactConnections { connections }) => {
+ let users = connections
+ .iter()
+ .flat_map(|connection| [&connection.first, &connection.second])
+ .cloned()
+ .collect();
+ let connections = connections
+ .into_iter()
+ .map(|connection| (connection.first, connection.second))
+ .collect();
+ (users, connections)
+ }
};
self.repository.create_connections(connections).await?;
self.notifier
- .invalidate_contacts_for_users(msg.users.into_iter().collect())
+ .invalidate_contacts_for_users(users.into_iter().collect())
.await?;
Ok(())
}
@@ -70,16 +87,15 @@ impl<R: ContactsRepository, N: ContactsNotifier> ContactsService for ContactsDom
}
async fn add_contact_nodes(&self, nodes: ContactsNodes) -> Result<(), rootcause::Report> {
- self.process_message(nodes).await
+ self.process_message(ContactsMessage::Nodes(nodes)).await
}
}
/// Queue-backed implementation of [`ContactsIngress`].
///
-/// Serialises the user set into a [`ContactsMessage`] and publishes it through
-/// the provided [`ContactsIngressQueue`]. The heavy lifting (computing pairwise
-/// connections, persisting them) is done by the contacts service worker that
-/// consumes from that queue.
+/// Serialises complete-graph or explicit-relationship messages and publishes
+/// them through the provided [`ContactsIngressQueue`]. Persistence is handled
+/// by the contacts service worker that consumes from that queue.
pub struct SqsContactsIngress<Q> {
/// The queue used to publish contacts messages.
pub queue: Q,
@@ -90,7 +106,16 @@ impl<Q: ContactsIngressQueue> ContactsIngress for SqsContactsIngress<Q> {
&self,
users: HashSet<MacroUserIdStr<'static>>,
) -> Result<(), Report> {
- self.queue.publish(ContactsNodes { users }).await
+ self.queue.publish_nodes(ContactsNodes { users }).await
+ }
+
+ async fn enqueue_contact_connections(
+ &self,
+ connections: Vec<ContactConnection>,
+ ) -> Result<(), Report> {
+ self.queue
+ .publish_connections(ContactConnections::new(connections))
+ .await
}
}
diff --git a/crates/contacts/src/domain/service/test.rs b/crates/contacts/src/domain/service/test.rs
index 2386bc2c97..8d6a020805 100644
--- a/crates/contacts/src/domain/service/test.rs
+++ b/crates/contacts/src/domain/service/test.rs
@@ -1,5 +1,47 @@
-#[allow(unused_imports)]
use super::*;
+use crate::domain::models::messages::ContactConnection;
+use std::sync::Mutex;
+
+#[derive(Default)]
+struct RecordingRepository {
+ connections: Mutex<Vec<(MacroUserIdStr<'static>, MacroUserIdStr<'static>)>>,
+}
+
+impl ContactsRepository for RecordingRepository {
+ async fn get_contacts(
+ &self,
+ _user_id: MacroUserIdStr<'_>,
+ ) -> Result<Vec<MacroUserIdStr<'static>>, rootcause::Report> {
+ Ok(Vec::new())
+ }
+
+ async fn create_connections(
+ &self,
+ connections: Vec<(MacroUserIdStr<'_>, MacroUserIdStr<'_>)>,
+ ) -> Result<(), rootcause::Report> {
+ self.connections.lock().unwrap().extend(
+ connections
+ .into_iter()
+ .map(|(first, second)| (first.into_owned(), second.into_owned())),
+ );
+ Ok(())
+ }
+}
+
+struct NoopNotifier;
+
+impl ContactsNotifier for NoopNotifier {
+ async fn invalidate_contacts_for_users(
+ &self,
+ _user_ids: Vec<MacroUserIdStr<'_>>,
+ ) -> Result<(), rootcause::Report> {
+ Ok(())
+ }
+}
+
+fn user(email: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::try_from_email(email).unwrap()
+}
#[test]
fn test_deserialize_connections_message() {
@@ -9,6 +51,32 @@ fn test_deserialize_connections_message() {
assert_eq!(msg.unwrap().users.len(), 3);
}
+#[tokio::test]
+async fn explicit_connections_do_not_create_a_complete_graph() {
+ let owner = user("[email protected]");
+ let first = user("[email protected]");
+ let second = user("[email protected]");
+ let service = ContactsDomainService {
+ repository: RecordingRepository::default(),
+ notifier: NoopNotifier,
+ };
+
+ service
+ .process_message(ContactsMessage::Connections(ContactConnections::new(vec![
+ ContactConnection::new(owner.clone(), first.clone()),
+ ContactConnection::new(owner.clone(), second.clone()),
+ ])))
+ .await
+ .unwrap();
+
+ let connections = service.repository.connections.lock().unwrap();
+ assert_eq!(connections.len(), 2);
+ assert!(connections.contains(&(owner.clone(), first.clone())));
+ assert!(connections.contains(&(owner, second.clone())));
+ assert!(!connections.contains(&(first.clone(), second.clone())));
+ assert!(!connections.contains(&(second, first)));
+}
+
fn generate_sqs_message() -> aws_sdk_sqs::types::Message {
let input_json = include_str!("../../../tests/fixtures/add_connection.json");
aws_sdk_sqs::types::Message::builder()
@@ -20,6 +88,8 @@ fn generate_sqs_message() -> aws_sdk_sqs::types::Message {
fn test_message_from_aws_sqs() {
let sqs_message = generate_sqs_message();
let message = crate::inbound::worker::message_from_sqs(&sqs_message);
- assert!(message.is_some(), "Could not parse body from sqs message");
- assert_eq!(message.unwrap().users.len(), 3);
+ let Some(ContactsMessage::Nodes(message)) = message else {
+ panic!("Could not parse body as a contacts-nodes message");
+ };
+ assert_eq!(message.users.len(), 3);
}
diff --git a/crates/contacts/src/inbound/worker.rs b/crates/contacts/src/inbound/worker.rs
index 623a2002f4..215364d4e3 100644
--- a/crates/contacts/src/inbound/worker.rs
+++ b/crates/contacts/src/inbound/worker.rs
@@ -1,6 +1,6 @@
use std::time::Duration;
-use crate::domain::models::messages::ContactsNodes;
+use crate::domain::models::messages::ContactsMessage;
use crate::domain::ports::{ContactsNotifier, ContactsOutboxService, ContactsRepository};
use crate::domain::service::ContactsDomainService;
use rootcause::report;
@@ -89,12 +89,12 @@ impl<R: ContactsRepository, N: ContactsNotifier> ContactsWorker<R, N> {
}
/// Parses a JSON string into a [`ContactsMessage`].
-fn message_from_json(body: &str) -> Option<ContactsNodes> {
+fn message_from_json(body: &str) -> Option<ContactsMessage> {
serde_json::from_str(body).ok()
}
/// Extracts and parses the body from an SQS message.
-pub(crate) fn message_from_sqs(msg: &aws_sdk_sqs::types::Message) -> Option<ContactsNodes> {
+pub(crate) fn message_from_sqs(msg: &aws_sdk_sqs::types::Message) -> Option<ContactsMessage> {
msg.body.as_ref().and_then(|body| message_from_json(body))
}
diff --git a/crates/contacts/src/outbound/ingress.rs b/crates/contacts/src/outbound/ingress.rs
index c290d0345f..9d6c12edb7 100644
--- a/crates/contacts/src/outbound/ingress.rs
+++ b/crates/contacts/src/outbound/ingress.rs
@@ -1,4 +1,4 @@
-use crate::domain::models::messages::ContactsNodes;
+use crate::domain::models::messages::{ContactConnections, ContactsNodes};
use crate::domain::ports::ContactsIngressQueue;
use rootcause::Report;
@@ -16,10 +16,9 @@ impl SqsContactsQueue {
}
}
-impl ContactsIngressQueue for SqsContactsQueue {
- #[tracing::instrument(skip(self, message), err)]
- async fn publish(&self, message: ContactsNodes) -> Result<(), Report> {
- let body = serde_json::to_string(&message)?;
+impl SqsContactsQueue {
+ async fn publish<T: serde::Serialize>(&self, message: &T) -> Result<(), Report> {
+ let body = serde_json::to_string(message)?;
self.client
.send_message()
.queue_url(&self.queue_url)
@@ -29,3 +28,15 @@ impl ContactsIngressQueue for SqsContactsQueue {
Ok(())
}
}
+
+impl ContactsIngressQueue for SqsContactsQueue {
+ #[tracing::instrument(skip(self, message), err)]
+ async fn publish_nodes(&self, message: ContactsNodes) -> Result<(), Report> {
+ self.publish(&message).await
+ }
+
+ #[tracing::instrument(skip(self, message), err)]
+ async fn publish_connections(&self, message: ContactConnections) -> Result<(), Report> {
+ self.publish(&message).await
+ }
+}
diff --git a/crates/contacts/src/outbound/repository.rs b/crates/contacts/src/outbound/repository.rs
index 80967e72ce..332301fe56 100644
--- a/crates/contacts/src/outbound/repository.rs
+++ b/crates/contacts/src/outbound/repository.rs
@@ -8,6 +8,7 @@ use macro_user_id::user_id::MacroUserIdStr;
use rootcause::Report;
use sqlx::PgPool;
use sqlx::types::Uuid;
+use std::collections::HashSet;
/// Database-backed implementation of [`ContactsRepository`].
pub struct DbContactsRepository {
@@ -49,17 +50,25 @@ impl ContactsRepository for DbContactsRepository {
&self,
connections: Vec<(MacroUserIdStr<'_>, MacroUserIdStr<'_>)>,
) -> Result<(), Report> {
- let (users1, users2): (Vec<_>, Vec<_>) = connections
+ // Contacts are undirected: discard self-edges and canonicalize endpoint
+ // order so A-B and B-A deduplicate before reaching PostgreSQL.
+ let connections: HashSet<_> = connections
.into_iter()
.filter(|(a, b)| a.as_ref() != b.as_ref())
.map(|(a, b)| {
- if a.as_ref() <= b.as_ref() {
+ if a.as_ref() < b.as_ref() {
(a, b)
} else {
(b, a)
}
})
- .unzip();
+ .collect();
+
+ if connections.is_empty() {
+ return Ok(());
+ }
+
+ let (users1, users2): (Vec<_>, Vec<_>) = connections.into_iter().unzip();
let u1: Vec<&str> = users1.iter().map(|u| u.as_ref()).collect();
let u2: Vec<&str> = users2.iter().map(|u| u.as_ref()).collect();
diff --git a/crates/contacts/src/outbound/repository/test.rs b/crates/contacts/src/outbound/repository/test.rs
index b1abcddaa9..f8bd4dd5a1 100644
--- a/crates/contacts/src/outbound/repository/test.rs
+++ b/crates/contacts/src/outbound/repository/test.rs
@@ -42,6 +42,30 @@ async fn test_create_connections_ordering(pool: PgPool) -> sqlx::Result<()> {
Ok(())
}
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn test_create_connections_deduplicates_and_ignores_self_edges(
+ pool: PgPool,
+) -> sqlx::Result<()> {
+ let user1 = "macro|[email protected]";
+ let user2 = "macro|[email protected]";
+ let repo = DbContactsRepository::new(pool.clone());
+
+ repo.create_connections(vec![
+ (mid(user1), mid(user2)),
+ (mid(user2), mid(user1)),
+ (mid(user1), mid(user1)),
+ ])
+ .await
+ .unwrap();
+
+ let count = sqlx::query_scalar!("SELECT count(*) FROM contacts_connections")
+ .fetch_one(&pool)
+ .await?
+ .unwrap();
+ assert_eq!(count, 1);
+ Ok(())
+}
+
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "fixtures", scripts("user_list"))
diff --git a/services/email_service/src/bin/backfill_contacts/process.rs b/services/email_service/src/bin/backfill_contacts/process.rs
index 051c1d0f46..d28cbb5a03 100644
--- a/services/email_service/src/bin/backfill_contacts/process.rs
+++ b/services/email_service/src/bin/backfill_contacts/process.rs
@@ -1,3 +1,4 @@
+use contacts::domain::models::messages::ContactConnection;
use contacts::domain::ports::ContactsIngress;
use contacts::domain::service::SqsContactsIngress;
use contacts::outbound::ingress::SqsContactsQueue;
@@ -25,17 +26,16 @@ pub async fn process_macro_id(
return Ok(());
}
- let users: std::collections::HashSet<MacroUserIdStr<'static>> =
- std::iter::once(Ok(link.macro_id.clone()))
- .chain(
- contact_emails
- .iter()
- .map(|email| MacroUserIdStr::try_from_email(email)),
- )
- .collect::<Result<_, _>>()?;
+ let connections = contact_emails
+ .iter()
+ .map(|email| {
+ MacroUserIdStr::try_from_email(email)
+ .map(|contact| ContactConnection::new(link.macro_id.clone(), contact))
+ })
+ .collect::<Result<Vec<_>, _>>()?;
contacts_ingress
- .enqueue_contacts(users)
+ .enqueue_contact_connections(connections)
.await
.map_err(|e| anyhow::anyhow!("{e:?}"))?;
diff --git a/services/email_service/src/pubsub/backfill/increment_counters.rs b/services/email_service/src/pubsub/backfill/increment_counters.rs
index f788a02ba0..18dd918a1e 100644
--- a/services/email_service/src/pubsub/backfill/increment_counters.rs
+++ b/services/email_service/src/pubsub/backfill/increment_counters.rs
@@ -1,7 +1,6 @@
-use std::collections::HashSet;
-
use crate::pubsub::context::PubSubContext;
use crate::pubsub::util::cg_refresh_email;
+use contacts::domain::models::messages::ContactConnection;
use contacts::domain::ports::ContactsIngress;
use macro_user_id::user_id::MacroUserIdStr;
use models_email::api::refresh::{BackfillStatus, RefreshEmailEvent};
@@ -189,13 +188,13 @@ async fn handle_contacts_sync(ctx: &PubSubContext, link: &Link) -> Result<(), Pr
link.macro_id
);
- let users: HashSet<MacroUserIdStr<'static>> = std::iter::once(Ok(link.macro_id.clone()))
- .chain(
- email_addresses
- .iter()
- .map(|email| MacroUserIdStr::try_from_email(email)),
- )
- .collect::<Result<_, _>>()
+ let connections = email_addresses
+ .iter()
+ .map(|email| {
+ MacroUserIdStr::try_from_email(email)
+ .map(|contact| ContactConnection::new(link.macro_id.clone(), contact))
+ })
+ .collect::<Result<Vec<_>, _>>()
.map_err(|e| {
ProcessingError::NonRetryable(DetailedError {
reason: FailureReason::SqsEnqueueFailed,
@@ -204,7 +203,7 @@ async fn handle_contacts_sync(ctx: &PubSubContext, link: &Link) -> Result<(), Pr
})?;
ctx.contacts_ingress
- .enqueue_contacts(users)
+ .enqueue_contact_connections(connections)
.await
.map_err(|e| {
ProcessingError::NonRetryable(DetailedError {
diff --git a/services/email_service/src/pubsub/inbox_sync/operations/upsert_message.rs b/services/email_service/src/pubsub/inbox_sync/operations/upsert_message.rs
index 6ff22d0772..3d02e86b31 100644
--- a/services/email_service/src/pubsub/inbox_sync/operations/upsert_message.rs
+++ b/services/email_service/src/pubsub/inbox_sync/operations/upsert_message.rs
@@ -9,6 +9,7 @@ use crate::pubsub::util::{
use crate::pubsub::util::{cg_refresh_email, publish_email_event};
use crate::util::process_pre_insert::{process_message_pre_insert, process_threads_pre_insert};
use crate::util::upload_attachment::{UploadAttachmentContext, upload_attachment};
+use contacts::domain::models::messages::ContactConnection;
use contacts::domain::ports::ContactsIngress;
use email::domain::events::{
EmailEventOrigin, EmailMacroEvent, MessageReceivedMetadata, MessageSentMetadata,
@@ -451,23 +452,22 @@ async fn handle_contacts_sync(
return Ok(());
}
- let users: std::collections::HashSet<MacroUserIdStr<'static>> =
- std::iter::once(Ok(link.macro_id.clone()))
- .chain(
- connection_emails
- .iter()
- .map(|email| MacroUserIdStr::try_from_email(email)),
- )
- .collect::<Result<_, _>>()
- .map_err(|e| {
- ProcessingError::NonRetryable(DetailedError {
- reason: FailureReason::SqsEnqueueFailed,
- source: anyhow::anyhow!(e).context("invalid user email for contacts"),
- })
- })?;
+ let connections = connection_emails
+ .iter()
+ .map(|email| {
+ MacroUserIdStr::try_from_email(email)
+ .map(|contact| ContactConnection::new(link.macro_id.clone(), contact))
+ })
+ .collect::<Result<Vec<_>, _>>()
+ .map_err(|e| {
+ ProcessingError::NonRetryable(DetailedError {
+ reason: FailureReason::SqsEnqueueFailed,
+ source: anyhow::anyhow!(e).context("invalid user email for contacts"),
+ })
+ })?;
ctx.contacts_ingress
- .enqueue_contacts(users)
+ .enqueue_contact_connections(connections)
.await
.map_err(|e| {
ProcessingError::NonRetryable(DetailedError {