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(email): email attachment claim optimization (#5431)

Will Hutchinson007fc033cb8a
diff --git a/.sqlx/query-846364ec4db0ccd7521fa833fc3c83f6d2f8a4c485b19f85e5f028539df7822e.json b/.sqlx/query-846364ec4db0ccd7521fa833fc3c83f6d2f8a4c485b19f85e5f028539df7822e.json
new file mode 100644
index 0000000000..5e15f58905
--- /dev/null
+++ b/.sqlx/query-846364ec4db0ccd7521fa833fc3c83f6d2f8a4c485b19f85e5f028539df7822e.json
@@ -0,0 +1,25 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT EXISTS (\n SELECT 1\n FROM email_attachments a\n JOIN email_messages m ON a.message_id = m.id\n LEFT JOIN document_email de ON de.email_attachment_id = a.id\n WHERE m.link_id = $2\n AND m.provider_id = $1\n AND de.email_attachment_id IS NULL\n AND a.upload_claimed_at IS NULL\n AND a.filename IS NOT NULL\n AND (\n a.mime_type = ANY($3::text[])\n OR (\n a.mime_type = 'application/octet-stream'\n AND UPPER(SUBSTRING(a.filename FROM '\\.([^.]+)$')) = ANY($4::text[])\n )\n )\n ) AS \"has_candidate!\"\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "has_candidate!",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Uuid",
+ "TextArray",
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "846364ec4db0ccd7521fa833fc3c83f6d2f8a4c485b19f85e5f028539df7822e"
+}
diff --git a/crates/email_db_client/src/attachments/provider/upload.rs b/crates/email_db_client/src/attachments/provider/upload.rs
index 157f5ba655..1ac922f63e 100644
--- a/crates/email_db_client/src/attachments/provider/upload.rs
+++ b/crates/email_db_client/src/attachments/provider/upload.rs
@@ -1,6 +1,6 @@
use crate::attachments::provider::upload_filters::{
ATTACHMENT_MIME_TYPE_FILTERS, ATTACHMENT_MIME_TYPE_FILTERS_WITH_MEDIA,
- ATTACHMENT_WHITELISTED_DOMAINS,
+ ATTACHMENT_WHITELISTED_DOMAINS, DOCUMENT_MIME_TYPES, OCTET_STREAM_DOCUMENT_EXTENSIONS,
};
use models_email::service::attachment::AttachmentUploadMetadata;
use sqlx::types::Uuid;
@@ -220,6 +220,52 @@ pub async fn fetch_job_attachments_for_backfill(
Ok(attachments)
}
+async fn message_has_unclaimed_document_attachment(
+ db: &Pool<Postgres>,
+ link_id: Uuid,
+ message_provider_id: &str,
+) -> anyhow::Result<bool> {
+ let document_mime_types = DOCUMENT_MIME_TYPES
+ .iter()
+ .map(|value| (*value).to_owned())
+ .collect::<Vec<_>>();
+ let octet_stream_document_extensions = OCTET_STREAM_DOCUMENT_EXTENSIONS
+ .iter()
+ .map(|value| (*value).to_owned())
+ .collect::<Vec<_>>();
+
+ let has_candidate = sqlx::query_scalar!(
+ r#"
+ SELECT EXISTS (
+ SELECT 1
+ FROM email_attachments a
+ JOIN email_messages m ON a.message_id = m.id
+ LEFT JOIN document_email de ON de.email_attachment_id = a.id
+ WHERE m.link_id = $2
+ AND m.provider_id = $1
+ AND de.email_attachment_id IS NULL
+ AND a.upload_claimed_at IS NULL
+ AND a.filename IS NOT NULL
+ AND (
+ a.mime_type = ANY($3::text[])
+ OR (
+ a.mime_type = 'application/octet-stream'
+ AND UPPER(SUBSTRING(a.filename FROM '\.([^.]+)$')) = ANY($4::text[])
+ )
+ )
+ ) AS "has_candidate!"
+ "#,
+ message_provider_id,
+ link_id,
+ document_mime_types.as_slice(),
+ octet_stream_document_extensions.as_slice(),
+ )
+ .fetch_one(db)
+ .await?;
+
+ Ok(has_candidate)
+}
+
/// Fetch and atomically claim attachments for a specific message to upload to Macro.
/// This is called when a new email is inserted for a user. Attachments for the message
/// should be uploaded if any message in the message's thread meets any of the following criteria:
@@ -243,6 +289,10 @@ pub async fn new_email_document_atts(
link_id: Uuid,
message_provider_id: &str,
) -> anyhow::Result<Vec<AttachmentUploadMetadata>> {
+ if !message_has_unclaimed_document_attachment(db, link_id, message_provider_id).await? {
+ return Ok(Vec::new());
+ }
+
// query for conditions 1-4: claim attachments atomically and return metadata
let query1 = format!(
r#"
diff --git a/crates/email_db_client/src/attachments/provider/upload/test.rs b/crates/email_db_client/src/attachments/provider/upload/test.rs
index 733697c352..a7929d0ae0 100644
--- a/crates/email_db_client/src/attachments/provider/upload/test.rs
+++ b/crates/email_db_client/src/attachments/provider/upload/test.rs
@@ -287,6 +287,14 @@ async fn insertable_attachments_condition_5_previously_contacted(
assert_eq!(res[0].mime_type, "application/pdf");
assert_eq!(res[0].email_provider_id, "target-msg-401");
+ let second_res = new_email_document_atts(
+ &pool,
+ Uuid::parse_str("00000000-0000-0000-0000-00000000001a").unwrap(),
+ message_provider_id,
+ )
+ .await?;
+ assert!(second_res.is_empty());
+
Ok(())
}
@@ -637,6 +645,139 @@ async fn new_email_media_returns_empty_for_nonexistent_message(pool: Pool<Postgr
// Upload claim tests - verify attachments are atomically claimed
// ============================================================================
+fn claim_test_link_id() -> Uuid {
+ Uuid::parse_str("00000000-0000-0000-0000-000000000c01").unwrap()
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_finds_eligible_unclaimed_attachment(
+ pool: Pool<Postgres>,
+) -> Result<()> {
+ assert!(
+ message_has_unclaimed_document_attachment(
+ &pool,
+ claim_test_link_id(),
+ "claim-test-doc-msg"
+ )
+ .await?
+ );
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_excludes_preclaimed_attachment(
+ pool: Pool<Postgres>,
+) -> Result<()> {
+ assert!(
+ !message_has_unclaimed_document_attachment(
+ &pool,
+ claim_test_link_id(),
+ "claim-test-preclaimed-msg"
+ )
+ .await?
+ );
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(
+ path = "../../../../fixtures",
+ scripts("fetch_insertable_attachments_for_new_email")
+ )
+)]
+async fn document_candidate_probe_excludes_existing_document_email(
+ pool: Pool<Postgres>,
+) -> Result<()> {
+ let link_id = Uuid::parse_str("00000000-0000-0000-0000-00000000001a")?;
+
+ assert!(!message_has_unclaimed_document_attachment(&pool, link_id, "target-msg-701").await?);
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_excludes_unsupported_mime_types(
+ pool: Pool<Postgres>,
+) -> Result<()> {
+ assert!(
+ !message_has_unclaimed_document_attachment(
+ &pool,
+ claim_test_link_id(),
+ "claim-test-media-msg"
+ )
+ .await?
+ );
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_excludes_missing_filenames(pool: Pool<Postgres>) -> Result<()> {
+ sqlx::query!(
+ r#"
+ UPDATE email_attachments
+ SET filename = NULL
+ WHERE message_id = '00000000-0000-0000-0000-0000000ec101'
+ "#
+ )
+ .execute(&pool)
+ .await?;
+
+ assert!(
+ !message_has_unclaimed_document_attachment(
+ &pool,
+ claim_test_link_id(),
+ "claim-test-doc-msg"
+ )
+ .await?
+ );
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_excludes_unknown_message(pool: Pool<Postgres>) -> Result<()> {
+ assert!(
+ !message_has_unclaimed_document_attachment(&pool, claim_test_link_id(), "unknown-message")
+ .await?
+ );
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
+)]
+async fn document_candidate_probe_excludes_mismatched_link(pool: Pool<Postgres>) -> Result<()> {
+ let other_link_id = Uuid::parse_str("00000000-0000-0000-0000-00000000001a")?;
+
+ assert!(
+ !message_has_unclaimed_document_attachment(&pool, other_link_id, "claim-test-doc-msg")
+ .await?
+ );
+
+ Ok(())
+}
+
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../../fixtures", scripts("upload_claim_tests"))
diff --git a/crates/email_db_client/src/attachments/provider/upload_filters.rs b/crates/email_db_client/src/attachments/provider/upload_filters.rs
index 053ac0b3f3..1c89d16c6c 100644
--- a/crates/email_db_client/src/attachments/provider/upload_filters.rs
+++ b/crates/email_db_client/src/attachments/provider/upload_filters.rs
@@ -1,25 +1,98 @@
-/// only insert attachments with these mime types.
-pub const ATTACHMENT_MIME_TYPE_FILTERS: &str = r#"
- AND (
- a.mime_type IN (
- 'application/pdf',
- 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
- 'application/msword',
- 'text/html',
- 'text/plain',
- 'pdf'
- )
- OR (
- a.mime_type = 'application/octet-stream'
- AND UPPER(SUBSTRING(a.filename FROM '\.([^.]+)$')) IN ('PDF', 'DOC', 'DOCX', 'TXT', 'HTML')
- )
- )
-"#;
+#[cfg(test)]
+mod test;
-/// Attachment mime type filters including videos and inline images
-pub const ATTACHMENT_MIME_TYPE_FILTERS_WITH_MEDIA: &str = r#"
- (a.mime_type LIKE 'image/%' OR a.mime_type LIKE 'video/%')
-"#;
+macro_rules! define_attachment_filters {
+ (
+ document_mime_types: [$($document_mime_type:literal,)* ; $last_document_mime_type:literal],
+ octet_stream_extensions: [$($extension:literal,)* ; $last_extension:literal],
+ media_mime_prefixes: [$first_media_prefix:literal $(, $media_prefix:literal)* $(,)?],
+ ) => {
+ /// MIME types treated as document attachments.
+ pub const DOCUMENT_MIME_TYPES: &[&str] = &[
+ $($document_mime_type,)*
+ $last_document_mime_type,
+ ];
+
+ /// Filename extensions treated as documents for octet-stream attachments.
+ pub const OCTET_STREAM_DOCUMENT_EXTENSIONS: &[&str] = &[
+ $($extension,)*
+ $last_extension,
+ ];
+
+ /// MIME type prefixes treated as media attachments.
+ pub const MEDIA_MIME_PREFIXES: &[&str] = &[
+ $first_media_prefix,
+ $($media_prefix,)*
+ ];
+
+ /// SQL filter for document attachments.
+ pub const ATTACHMENT_MIME_TYPE_FILTERS: &str = concat!(
+ "\n AND (\n",
+ " a.mime_type IN (\n",
+ $(" '", $document_mime_type, "',\n",)*
+ " '", $last_document_mime_type, "'\n",
+ " )\n",
+ " OR (\n",
+ " a.mime_type = 'application/octet-stream' \n",
+ " AND UPPER(SUBSTRING(a.filename FROM '\\.([^.]+)$')) IN (",
+ $("'", $extension, "', ",)*
+ "'", $last_extension, "')\n",
+ " )\n",
+ " )\n",
+ );
+
+ /// SQL filter for media attachments.
+ pub const ATTACHMENT_MIME_TYPE_FILTERS_WITH_MEDIA: &str = concat!(
+ "\n (a.mime_type LIKE '", $first_media_prefix, "%'",
+ $(" OR a.mime_type LIKE '", $media_prefix, "%'",)*
+ ")\n",
+ );
+ };
+}
+
+define_attachment_filters! {
+ document_mime_types: [
+ "application/pdf",
+ "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+ "application/msword",
+ "text/html",
+ "text/plain",
+ ; "pdf"
+ ],
+ octet_stream_extensions: ["PDF", "DOC", "DOCX", "TXT", ; "HTML"],
+ media_mime_prefixes: ["image/", "video/"],
+}
+
+/// Returns whether an attachment matches the document filter.
+pub fn attachment_is_document(mime_type: &str, filename: Option<&str>) -> bool {
+ let Some(filename) = filename else {
+ return false;
+ };
+
+ if DOCUMENT_MIME_TYPES.contains(&mime_type) {
+ return true;
+ }
+
+ if mime_type != "application/octet-stream" {
+ return false;
+ }
+
+ filename
+ .rsplit_once('.')
+ .map(|(_, extension)| {
+ OCTET_STREAM_DOCUMENT_EXTENSIONS
+ .iter()
+ .any(|allowed| extension.eq_ignore_ascii_case(allowed))
+ })
+ .unwrap_or(false)
+}
+
+/// Returns whether an attachment matches the media filter.
+pub fn attachment_is_media(mime_type: &str) -> bool {
+ MEDIA_MIME_PREFIXES
+ .iter()
+ .any(|prefix| mime_type.starts_with(prefix))
+}
/// always insert attachments sent from these domains.
pub const ATTACHMENT_WHITELISTED_DOMAINS: &str = r#"
diff --git a/crates/email_db_client/src/attachments/provider/upload_filters/test.rs b/crates/email_db_client/src/attachments/provider/upload_filters/test.rs
new file mode 100644
index 0000000000..0a3b8c5895
--- /dev/null
+++ b/crates/email_db_client/src/attachments/provider/upload_filters/test.rs
@@ -0,0 +1,123 @@
+use super::*;
+
+const LEGACY_DOCUMENT_FILTER: &str = r#"
+ AND (
+ a.mime_type IN (
+ 'application/pdf',
+ 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+ 'application/msword',
+ 'text/html',
+ 'text/plain',
+ 'pdf'
+ )
+ OR (
+ a.mime_type = 'application/octet-stream'
+ AND UPPER(SUBSTRING(a.filename FROM '\.([^.]+)$')) IN ('PDF', 'DOC', 'DOCX', 'TXT', 'HTML')
+ )
+ )
+"#;
+
+const LEGACY_MEDIA_FILTER: &str = r#"
+ (a.mime_type LIKE 'image/%' OR a.mime_type LIKE 'video/%')
+"#;
+
+#[test]
+fn generated_sql_matches_legacy_filters() {
+ assert_eq!(ATTACHMENT_MIME_TYPE_FILTERS, LEGACY_DOCUMENT_FILTER);
+ assert_eq!(ATTACHMENT_MIME_TYPE_FILTERS_WITH_MEDIA, LEGACY_MEDIA_FILTER);
+}
+
+#[test]
+fn every_document_mime_type_is_allowed() {
+ for mime_type in DOCUMENT_MIME_TYPES {
+ assert!(attachment_is_document(mime_type, Some("attachment")));
+ }
+}
+
+#[test]
+fn every_octet_stream_document_extension_is_allowed_case_insensitively() {
+ for extension in OCTET_STREAM_DOCUMENT_EXTENSIONS {
+ let lowercase_filename = format!("attachment.{}", extension.to_ascii_lowercase());
+ let mixed_case_extension = extension
+ .chars()
+ .enumerate()
+ .map(|(index, character)| {
+ if index % 2 == 0 {
+ character.to_ascii_lowercase()
+ } else {
+ character
+ }
+ })
+ .collect::<String>();
+ let mixed_case_filename = format!("attachment.{mixed_case_extension}");
+
+ assert!(attachment_is_document(
+ "application/octet-stream",
+ Some(&lowercase_filename)
+ ));
+ assert!(attachment_is_document(
+ "application/octet-stream",
+ Some(&mixed_case_filename)
+ ));
+ }
+}
+
+#[test]
+fn octet_stream_uses_the_final_filename_extension() {
+ assert!(attachment_is_document(
+ "application/octet-stream",
+ Some("quarterly.report.final.DoCx")
+ ));
+ assert!(!attachment_is_document(
+ "application/octet-stream",
+ Some("report.pdf.exe")
+ ));
+}
+
+#[test]
+fn document_filter_rejects_missing_or_unsupported_metadata() {
+ assert!(!attachment_is_document("application/pdf", None));
+ assert!(!attachment_is_document("application/octet-stream", None));
+ assert!(!attachment_is_document(
+ "application/octet-stream",
+ Some("attachment")
+ ));
+ assert!(!attachment_is_document(
+ "application/octet-stream",
+ Some("attachment.")
+ ));
+ assert!(!attachment_is_document(
+ "application/octet-stream",
+ Some("attachment.csv")
+ ));
+ assert!(!attachment_is_document("application/zip", Some("file.pdf")));
+ assert!(!attachment_is_document("text/css", Some("styles.css")));
+}
+
+#[test]
+fn document_mime_type_matching_is_case_sensitive() {
+ assert!(!attachment_is_document(
+ "Application/Pdf",
+ Some("attachment.pdf")
+ ));
+ assert!(!attachment_is_document("PDF", Some("attachment.pdf")));
+ assert!(!attachment_is_document(
+ "Application/Octet-Stream",
+ Some("attachment.pdf")
+ ));
+}
+
+#[test]
+fn every_media_mime_prefix_is_allowed() {
+ for prefix in MEDIA_MIME_PREFIXES {
+ assert!(attachment_is_media(&format!("{prefix}example")));
+ }
+}
+
+#[test]
+fn media_filter_is_case_sensitive_and_rejects_other_types() {
+ assert!(!attachment_is_media("Image/png"));
+ assert!(!attachment_is_media("VIDEO/mp4"));
+ assert!(!attachment_is_media("application/pdf"));
+ assert!(!attachment_is_media("text/plain"));
+}
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 15d9f8a01f..f8ada1bbc1 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
@@ -17,6 +17,9 @@ use email::domain::events::{
use email::domain::models::{PreviewCursorQuery, PreviewView, PreviewViewStandardLabel};
use email::domain::ports::EmailRepo;
use email::outbound::EmailPgRepo;
+use email_db_client::attachments::provider::upload_filters::{
+ attachment_is_document, attachment_is_media,
+};
use email_db_client::threads;
use email_utils::dedupe_emails;
use filter_ast::Expr;
@@ -31,7 +34,9 @@ use models_email::email::service::link;
use models_email::email::service::message::SimpleMessage;
use models_email::gmail::inbox_sync::{InboxSyncOperation, UpsertMessagePayload};
use models_email::gmail::operations::GmailApiOperation;
-use models_email::service::attachment::{AttachmentUploadArgs, AttachmentUploadDestination};
+use models_email::service::attachment::{
+ Attachment, AttachmentUploadArgs, AttachmentUploadDestination, AttachmentUploadMetadata,
+};
use models_email::service::message::{Message, is_spam_or_trash};
use models_email::service::pubsub::{DetailedError, FailureReason, ProcessingError};
use notification::domain::models::SendNotificationRequestBuilder;
@@ -116,7 +121,7 @@ pub async fn upsert_message(
let calendar_payload = message_resource.payload.clone();
// Map Gmail resource to service model (IDs are generated in the parse function)
- let message = map_message_resource_to_service(message_resource, link.id).map_err(|e| {
+ let mut message = map_message_resource_to_service(message_resource, link.id).map_err(|e| {
ProcessingError::NonRetryable(DetailedError {
reason: FailureReason::GmailApiFailed,
source: e.context("Failed to map message resource to service".to_string()),
@@ -229,7 +234,7 @@ pub async fn upsert_message(
// if the message's thread doesn't exist in the database, we need to fetch and insert the whole thread.
// if it does exist in the database, we just need to insert the already fetched message.
if let Some(thread_db_id) = thread_provider_to_db_map.get(&provider_thread_id) {
- process_and_insert_message(ctx, link.id, *thread_db_id, message)
+ process_and_insert_message(ctx, link.id, *thread_db_id, &mut message)
.await
.map_err(|e| {
ProcessingError::NonRetryable(DetailedError {
@@ -354,7 +359,7 @@ pub async fn upsert_message(
&gmail_access_token,
link,
payload,
- message_attachment_count,
+ &message.attachments,
)
.await?;
@@ -399,30 +404,50 @@ pub async fn upsert_message(
Ok(())
}
-#[tracing::instrument(skip(ctx, gmail_access_token))]
+#[tracing::instrument(skip(ctx, gmail_access_token, attachments), err)]
async fn handle_attachment_upload(
ctx: &PubSubContext,
gmail_access_token: &str,
link: &link::Link,
payload: &UpsertMessagePayload,
- message_attachment_count: usize,
+ attachments: &[Attachment],
) -> result::Result<(), ProcessingError> {
- if cfg!(not(feature = "attachment_upload")) || message_attachment_count == 0 {
+ if cfg!(not(feature = "attachment_upload")) {
+ return Ok(());
+ }
+
+ // Keep this parsed-attachment gate at least as permissive as the database claim filters.
+ let eligibility = attachment_upload_eligibility(attachments);
+ if !eligibility.documents && !eligibility.media {
return Ok(());
}
// upload attachments to Macro
let (document_atts, media_atts) = tokio::try_join!(
- email_db_client::attachments::provider::upload::new_email_document_atts(
- &ctx.db,
- link.id,
- &payload.provider_message_id,
- ),
- email_db_client::attachments::provider::upload::new_email_media_atts(
- &ctx.db,
- link.id,
- &payload.provider_message_id,
- )
+ async {
+ if eligibility.documents {
+ email_db_client::attachments::provider::upload::new_email_document_atts(
+ &ctx.db,
+ link.id,
+ &payload.provider_message_id,
+ )
+ .await
+ } else {
+ Ok(Vec::<AttachmentUploadMetadata>::new())
+ }
+ },
+ async {
+ if eligibility.media {
+ email_db_client::attachments::provider::upload::new_email_media_atts(
+ &ctx.db,
+ link.id,
+ &payload.provider_message_id,
+ )
+ .await
+ } else {
+ Ok(Vec::<AttachmentUploadMetadata>::new())
+ }
+ }
)
.map_err(|e| {
ProcessingError::Retryable(DetailedError {
@@ -500,6 +525,27 @@ async fn handle_attachment_upload(
Ok(())
}
+#[derive(Debug, Default, PartialEq, Eq)]
+struct AttachmentUploadEligibility {
+ documents: bool,
+ media: bool,
+}
+
+fn attachment_upload_eligibility(attachments: &[Attachment]) -> AttachmentUploadEligibility {
+ let mut eligibility = AttachmentUploadEligibility::default();
+
+ for attachment in attachments {
+ let Some(mime_type) = attachment.mime_type.as_deref() else {
+ continue;
+ };
+
+ eligibility.documents |= attachment_is_document(mime_type, attachment.filename.as_deref());
+ eligibility.media |= attachment_is_media(mime_type);
+ }
+
+ eligibility
+}
+
#[tracing::instrument(skip(ctx, link, recipient_emails, sender_email))]
async fn handle_contacts_sync(
ctx: &PubSubContext,
@@ -619,14 +665,14 @@ async fn process_and_insert_message(
ctx: &PubSubContext,
link_id: Uuid,
thread_db_id: Uuid,
- mut message: Message,
+ message: &mut Message,
) -> anyhow::Result<()> {
- process_message_pre_insert(&mut message).await;
+ process_message_pre_insert(message).await;
email_db_client::messages::insert::insert_message(
&ctx.db,
thread_db_id,
- &mut message,
+ message,
link_id,
true,
)
diff --git a/services/email_service/src/pubsub/inbox_sync/operations/upsert_message/test.rs b/services/email_service/src/pubsub/inbox_sync/operations/upsert_message/test.rs
index 126d7dac23..687f06b1fb 100644
--- a/services/email_service/src/pubsub/inbox_sync/operations/upsert_message/test.rs
+++ b/services/email_service/src/pubsub/inbox_sync/operations/upsert_message/test.rs
@@ -4,6 +4,104 @@ fn id(s: &str) -> MacroUserIdStr<'static> {
MacroUserIdStr::try_from(s.to_string()).unwrap()
}
+fn attachment(mime_type: Option<&str>, filename: Option<&str>) -> Attachment {
+ Attachment {
+ db_id: Uuid::new_v4(),
+ provider_id: None,
+ data_url: None,
+ filename: filename.map(str::to_string),
+ mime_type: mime_type.map(str::to_string),
+ size_bytes: None,
+ sfs_id: None,
+ content_id: None,
+ }
+}
+
+fn assert_attachment_eligibility(attachments: &[Attachment], documents: bool, media: bool) {
+ assert_eq!(
+ attachment_upload_eligibility(attachments),
+ AttachmentUploadEligibility { documents, media }
+ );
+}
+
+#[test]
+fn no_attachments_are_ineligible_for_upload() {
+ assert_attachment_eligibility(&[], false, false);
+}
+
+#[test]
+fn inline_image_only_is_media_eligible() {
+ let mut inline_image = attachment(Some("image/png"), Some("signature.png"));
+ inline_image.content_id = Some("signature-image".to_string());
+
+ assert_attachment_eligibility(&[inline_image], false, true);
+}
+
+#[test]
+fn unsupported_and_text_only_parts_are_ineligible_for_upload() {
+ let attachments = [
+ attachment(Some("application/json"), Some("metadata.json")),
+ attachment(Some("text/css"), Some("styles.css")),
+ ];
+
+ assert_attachment_eligibility(&attachments, false, false);
+}
+
+#[test]
+fn document_only_is_document_eligible() {
+ let attachments = [attachment(Some("application/pdf"), Some("report.pdf"))];
+
+ assert_attachment_eligibility(&attachments, true, false);
+}
+
+#[test]
+fn media_only_is_media_eligible() {
+ let attachments = [attachment(Some("video/mp4"), Some("recording.mp4"))];
+
+ assert_attachment_eligibility(&attachments, false, true);
+}
+
+#[test]
+fn mixed_document_and_media_are_both_eligible() {
+ let attachments = [
+ attachment(Some("application/msword"), Some("report.doc")),
+ attachment(Some("image/jpeg"), Some("photo.jpg")),
+ ];
+
+ assert_attachment_eligibility(&attachments, true, true);
+}
+
+#[test]
+fn octet_stream_requires_a_valid_document_extension() {
+ let valid = [attachment(
+ Some("application/octet-stream"),
+ Some("report.final.DoCx"),
+ )];
+ let invalid = [attachment(
+ Some("application/octet-stream"),
+ Some("report.pdf.exe"),
+ )];
+
+ assert_attachment_eligibility(&valid, true, false);
+ assert_attachment_eligibility(&invalid, false, false);
+}
+
+#[test]
+fn missing_mime_type_matches_neither_category() {
+ let attachments = [attachment(None, Some("report.pdf"))];
+
+ assert_attachment_eligibility(&attachments, false, false);
+}
+
+#[test]
+fn missing_filename_excludes_documents_but_not_media() {
+ let document = [attachment(Some("application/pdf"), None)];
+ let media = [attachment(Some("image/png"), None)];
+
+ assert_attachment_eligibility(&document, false, false);
+ assert_attachment_eligibility(&media, false, true);
+}
+
#[test]
fn includes_owner_and_all_delegated_primaries() {
let owner = id("macro|[email protected]");