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.

8.2 KB
Raw Blame
pub(crate) mod calendar_event;
pub(crate) mod call;
pub(crate) mod channel;
pub(crate) mod chat;
pub mod context;
pub(crate) mod document;
pub(crate) mod email;
pub(crate) mod project;
pub(crate) mod properties;
mod user;
pub mod worker;

use anyhow::Context;
use sqs_client::search::SearchQueueMessage;
use uuid::Uuid;

use crate::process::context::SearchProcessingContext;

/// Processes a message from the search text extractor queue.
/// If the processing  is successful, the message is deleted.
#[tracing::instrument(skip(ctx, message), fields(message_id=message.message_id))]
pub async fn process_message(
    ctx: &SearchProcessingContext,
    message: &aws_sdk_sqs::types::Message,
) -> anyhow::Result<()> {
    let start_time = std::time::Instant::now();

    let message_str = message.body().context("message body is empty")?;

    let search_extractor_message: SearchQueueMessage =
        serde_json::from_str(message_str).context("failed to deserialize message")?;

    tracing::trace!(
        search_extractor_message=?search_extractor_message,
        "received search extractor message"
    );

    match search_extractor_message {
        SearchQueueMessage::RemoveUserProfile(user_profile_id) => {
            tracing::trace!(user_profile_id = user_profile_id, "removing user profile");
            user::remove_user_profile(&ctx.opensearch_client, &user_profile_id).await?;
        }
        SearchQueueMessage::ChannelMessageUpdate(message) => {
            let channel_id = message
                .channel_id
                .parse::<Uuid>()
                .context("failed to parse channel_id as UUID")?;
            let message_id = message
                .message_id
                .parse::<Uuid>()
                .context("failed to parse message_id as UUID")?;
            channel::process_channel_message_update(
                &ctx.opensearch_client,
                &ctx.db,
                channel_id,
                message_id,
                message.index_override.as_deref(),
            )
            .await?;
        }
        SearchQueueMessage::ExtractEmailThreadBatch(message) => {
            let thread_ids = message
                .thread_ids
                .iter()
                .map(|thread_id| {
                    thread_id
                        .parse::<Uuid>()
                        .context("failed to parse thread_id as UUID")
                })
                .collect::<anyhow::Result<Vec<_>>>()?;
            email::upsert::process_upsert_thread_batch_message(
                &ctx.opensearch_client,
                &ctx.db,
                &thread_ids,
                &message.macro_user_id,
                message.index_override.as_deref(),
            )
            .await?;
        }
        SearchQueueMessage::ExtractDocumentText(message) => {
            document::process_extract_text_message(
                &ctx.opensearch_client,
                &ctx.db,
                &ctx.s3_client,
                &ctx.document_storage_bucket,
                &message,
            )
            .await?;
        }
        SearchQueueMessage::ExtractSync(message) => {
            document::process_extract_sync_message(
                &ctx.opensearch_client,
                &ctx.db,
                &ctx.s3_client,
                &ctx.document_storage_bucket,
                &ctx.lexical_client,
                &message,
            )
            .await?;
        }
        SearchQueueMessage::ChatMessage(message) => {
            chat::insert_chat_message(&ctx.opensearch_client, &ctx.db, &message).await?;
        }
        SearchQueueMessage::CallRecord(message) => {
            let call_id = message
                .call_id
                .parse::<Uuid>()
                .context("failed to parse call_id as UUID")?;
            call::process_call_record(
                &ctx.opensearch_client,
                &ctx.db,
                call_id,
                message.index_override.as_deref(),
            )
            .await?;
        }
        SearchQueueMessage::RemoveCallRecord(message) => {
            let channel_id = message
                .channel_id
                .parse::<Uuid>()
                .context("failed to parse channel_id as UUID")?;
            let call_id = message
                .call_id
                .as_deref()
                .map(Uuid::parse_str)
                .transpose()
                .context("failed to parse call_id as UUID")?;
            call::process_remove_call_record(
                &ctx.opensearch_client,
                Some(channel_id),
                call_id,
                message.index_override.as_deref(),
            )
            .await?;
        }
        SearchQueueMessage::UpsertProject(message) => {
            project::upsert_project(&ctx.opensearch_client, &ctx.db, &message).await?;
        }
        SearchQueueMessage::UpsertCalendarEvent(message) => {
            // Logged rather than silent: running the calendar backfill against
            // an environment where the flag is off should say why nothing
            // happened instead of reporting a successful no-op.
            if ctx.calendar_search_enabled {
                calendar_event::upsert_calendar_event(&ctx.opensearch_client, &ctx.db, &message)
                    .await?;
            } else {
                tracing::info!(
                    event_id = message.event_id,
                    "calendar search is disabled; not indexing calendar event"
                );
            }
        }
    }

    ctx.worker.cleanup_message(message).await?;

    tracing::trace!(time_elapsed=?start_time.elapsed(), "message processed");
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use model::document::FileType;
    use sqs_client::search::document::SearchExtractorMessage;

    #[test]
    fn test_deserialize_search_extractor_message() {
        let message = serde_json::json!({
            "user_id": "user_id",
            "document_id": "document_id",
            "file_type": "pdf"
        });
        let message: SearchExtractorMessage = serde_json::from_value(message).unwrap();

        assert_eq!(
            message,
            SearchExtractorMessage {
                user_id: "user_id".to_string(),
                document_id: "document_id".to_string(),
                file_type: FileType::Pdf,
                document_version_id: None,
                index_override: None,
            }
        );

        let message = serde_json::json!({
            "user_id": "user_id",
            "document_id": "document_id",
            "file_type": "docx",
            "document_version_id": "1"
        });
        let message: SearchExtractorMessage = serde_json::from_value(message).unwrap();

        assert_eq!(
            message,
            SearchExtractorMessage {
                user_id: "user_id".to_string(),
                document_id: "document_id".to_string(),
                file_type: FileType::Docx,
                document_version_id: Some("1".to_string()),
                index_override: None,
            }
        );

        let message = serde_json::json!({
            "user_id": "user_id",
            "document_id": "document_id",
            "file_type": "BAD ONE"
        });
        let error = serde_json::from_value::<SearchExtractorMessage>(message).unwrap_err();

        assert!(error.to_string().starts_with("unknown variant `BAD ONE`"));
    }

    #[test]
    fn test_deserialize_search_queue_message() -> anyhow::Result<()> {
        let message_str = r#"{"ExtractDocumentText":{"user_id":"macro|[email protected]","document_id":"253880fb-77d4-4e6c-856d-9f52c2d9a8b0","file_type":"md","document_version_id":"565533"}}"#;

        let search_extractor_message: SearchQueueMessage =
            serde_json::from_str(message_str).context("failed to deserialize message")?;

        assert_eq!(
            search_extractor_message,
            SearchQueueMessage::ExtractDocumentText(SearchExtractorMessage {
                user_id: "macro|[email protected]".to_string(),
                document_id: "253880fb-77d4-4e6c-856d-9f52c2d9a8b0".to_string(),
                file_type: FileType::Md,
                document_version_id: Some("565533".to_string()),
                index_override: None,
            })
        );

        Ok(())
    }
}