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.

11.4 KB
Raw Blame
use crate::SQS;
use models_email::email::service::backfill::BackfillPubsubMessage;
use models_email::email::service::crm_cleanup::CrmCleanupPubsubMessage;
pub use models_email::email::service::pubsub::LinkManagerMessage;
#[cfg(feature = "sfs_uploader")]
use models_email::service::pubsub::SFSUploaderMessage;
use models_email::service::pubsub::ScheduledPubsubMessage;
use uuid::Uuid;

/// Message attribute counting how often a backfill operation has been sent
/// back to its queue by [`SQS::defer_email_backfill_message`].
pub const BACKFILL_DEFERRALS_ATTRIBUTE: &str = "deferrals";

impl SQS {
    /// Enqueues one Gmail label write, split into operations no larger than a
    /// provider batch. Each operation clears its message's `pending_write_id`
    /// marker when it finishes.
    pub async fn enqueue_gmail_label_write(
        &self,
        link_id: Uuid,
        messages: Vec<(Uuid, String)>,
        labels_to_add: Vec<String>,
        labels_to_remove: Vec<String>,
        pending_write_id: Uuid,
    ) -> anyhow::Result<()> {
        let messages = self.gmail_label_write_messages(
            link_id,
            messages,
            labels_to_add,
            labels_to_remove,
            pending_write_id,
        );
        if !self.gmail_label_write_batches {
            return self.enqueue_gmail_ops_notifications_batch(messages).await;
        }
        // A full batch is ~100 KB, so each goes out alone rather than in an
        // SQS batch whose 256 KB cap is shared by all its entries.
        for message in messages {
            self.enqueue_gmail_ops_notification(message).await?;
        }
        Ok(())
    }

    pub fn email_link_manager_queue(mut self, link_manager_queue: &str) -> Self {
        self.link_manager_queue = Some(link_manager_queue.to_string());
        self
    }

    pub fn email_scheduled_queue(mut self, email_scheduled_queue: &str) -> Self {
        self.email_scheduled_queue = Some(email_scheduled_queue.to_string());
        self
    }

    pub fn email_backfill_queue(mut self, email_backfill_queue: &str) -> Self {
        self.email_backfill_queue = Some(email_backfill_queue.to_string());
        self
    }

    /// Send Gmail label writes as `ModifyMessageLabelsBatch` messages. Enable
    /// only once every gmail_ops worker decodes them; workers released before
    /// the batch form delete it. Off, each message is its own operation.
    pub fn gmail_label_write_batches(mut self, enabled: bool) -> Self {
        self.gmail_label_write_batches = enabled;
        self
    }

    /// The gmail_ops queue messages for one label write, in the format this
    /// client is configured for.
    fn gmail_label_write_messages(
        &self,
        link_id: Uuid,
        messages: Vec<(Uuid, String)>,
        labels_to_add: Vec<String>,
        labels_to_remove: Vec<String>,
        pending_write_id: Uuid,
    ) -> Vec<models_email::gmail::gmail_ops::GmailOpsPubsubMessage> {
        use models_email::gmail::gmail_ops::{
            GmailMessageRef, GmailOpsPubsubMessage, label_write_operations,
        };

        let messages = messages
            .into_iter()
            .map(|(db_message_id, provider_message_id)| GmailMessageRef {
                db_message_id,
                provider_message_id,
            })
            .collect();
        label_write_operations(
            messages,
            labels_to_add,
            labels_to_remove,
            pending_write_id,
            self.gmail_label_write_batches,
        )
        .into_iter()
        .map(|operation| GmailOpsPubsubMessage { link_id, operation })
        .collect()
    }

    pub fn email_crm_cleanup_queue(mut self, email_crm_cleanup_queue: &str) -> Self {
        self.email_crm_cleanup_queue = Some(email_crm_cleanup_queue.to_string());
        self
    }

    #[cfg(feature = "sfs_uploader")]
    pub fn sfs_uploader_queue(mut self, email_sfs_uploader_queue: &str) -> Self {
        self.email_sfs_uploader_queue = Some(email_sfs_uploader_queue.to_string());
        self
    }

    #[cfg(feature = "sfs_delete")]
    pub fn sfs_delete_queue(mut self, email_sfs_delete_queue: &str) -> Self {
        self.email_sfs_delete_queue = Some(email_sfs_delete_queue.to_string());
        self
    }

    /// Sends a notification message to the email refresh queue
    #[tracing::instrument(skip(self))]
    pub async fn enqueue_link_manager_notification(
        &self,
        message: LinkManagerMessage,
    ) -> anyhow::Result<()> {
        if let Some(link_manager_queue) = &self.link_manager_queue {
            return enqueue_link_manager_notification(&self.inner, link_manager_queue, message)
                .await;
        }
        anyhow::bail!("link_manager_queue is not configured")
    }

    /// Sends a message to the email backfill queue
    #[tracing::instrument(skip(self))]
    pub async fn enqueue_email_backfill_message(
        &self,
        message: BackfillPubsubMessage,
    ) -> anyhow::Result<()> {
        if let Some(email_backfill_queue) = &self.email_backfill_queue {
            return enqueue_backfill_message(&self.inner, email_backfill_queue, message).await;
        }
        Err(anyhow::anyhow!("email_backfill_queue is not configured"))
    }

    /// Sends a backfill operation back to the backfill queue as a new message
    /// that becomes visible after `delay_seconds`. Unlike waiting out the
    /// visibility timeout, the wait uses none of the operation's deliveries.
    /// `deferrals` is recorded in [`BACKFILL_DEFERRALS_ATTRIBUTE`].
    #[tracing::instrument(skip(self), err)]
    pub async fn defer_email_backfill_message(
        &self,
        message: &BackfillPubsubMessage,
        delay_seconds: i32,
        deferrals: u32,
    ) -> anyhow::Result<()> {
        let Some(email_backfill_queue) = &self.email_backfill_queue else {
            anyhow::bail!("email_backfill_queue is not configured");
        };
        let deferrals = aws_sdk_sqs::types::MessageAttributeValue::builder()
            .data_type("Number")
            .string_value(deferrals.to_string())
            .build()?;
        self.inner
            .send_message()
            .queue_url(email_backfill_queue)
            .message_body(serde_json::to_string(&message)?)
            .delay_seconds(delay_seconds)
            .message_attributes(BACKFILL_DEFERRALS_ATTRIBUTE, deferrals)
            .send()
            .await?;
        Ok(())
    }

    /// Sends a message to the email crm cleanup queue
    #[tracing::instrument(skip(self), err)]
    pub async fn enqueue_email_crm_cleanup_message(
        &self,
        message: CrmCleanupPubsubMessage,
    ) -> anyhow::Result<()> {
        if let Some(email_crm_cleanup_queue) = &self.email_crm_cleanup_queue {
            return enqueue_crm_cleanup_message(&self.inner, email_crm_cleanup_queue, message)
                .await;
        }
        anyhow::bail!("email_crm_cleanup_queue is not configured")
    }

    /// Sends a message to the email scheduled queue
    #[tracing::instrument(skip(self))]
    pub async fn enqueue_email_scheduled_message(
        &self,
        message: ScheduledPubsubMessage,
        delay_seconds: Option<i32>,
    ) -> anyhow::Result<()> {
        if let Some(email_scheduled_queue) = &self.email_scheduled_queue {
            return enqueue_scheduled_message(
                &self.inner,
                email_scheduled_queue,
                message,
                delay_seconds,
            )
            .await;
        }
        Err(anyhow::anyhow!("email_scheduled_queue is not configured"))
    }

    /// Sends a notification message to the email sfs uploader queue
    #[cfg(feature = "sfs_uploader")]
    #[tracing::instrument(skip(self))]
    pub async fn enqueue_email_sfs_uploader_message(
        &self,
        message: SFSUploaderMessage,
    ) -> anyhow::Result<()> {
        if let Some(queue) = &self.email_sfs_uploader_queue {
            return enqueue_sfs_uploader_message(&self.inner, queue, message).await;
        }
        Err(anyhow::anyhow!(
            "email_sfs_uploader_queue is not configured"
        ))
    }

    /// Sends a message to the sfs delete queue
    #[cfg(feature = "sfs_delete")]
    #[tracing::instrument(skip(self), err)]
    pub async fn enqueue_sfs_delete_message(
        &self,
        message: SFSDeleteMessage,
    ) -> anyhow::Result<()> {
        if let Some(queue) = &self.email_sfs_delete_queue {
            return enqueue_sfs_delete_message(&self.inner, queue, message).await;
        }
        anyhow::bail!("email_sfs_delete_queue is not configured")
    }
}

#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_link_manager_notification(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: LinkManagerMessage,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str)
        .send()
        .await?;
    Ok(())
}

#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_backfill_message(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: BackfillPubsubMessage,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    // Send the message with the serialized body
    sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str)
        .send()
        .await?;

    Ok(())
}

#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_crm_cleanup_message(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: CrmCleanupPubsubMessage,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str)
        .send()
        .await?;

    Ok(())
}

#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_scheduled_message(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: ScheduledPubsubMessage,
    delay_seconds: Option<i32>,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    let mut request = sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str);

    if let Some(delay) = delay_seconds {
        request = request.delay_seconds(delay);
    }

    request.send().await?;

    Ok(())
}

#[cfg(feature = "sfs_uploader")]
#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_sfs_uploader_message(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: SFSUploaderMessage,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    // Send the message with the serialized body
    sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str)
        .send()
        .await?;

    Ok(())
}

#[cfg(feature = "sfs_delete")]
#[tracing::instrument(skip(sqs_client))]
pub async fn enqueue_sfs_delete_message(
    sqs_client: &aws_sdk_sqs::Client,
    queue_url: &str,
    message: SFSDeleteMessage,
) -> anyhow::Result<()> {
    let message_str = serde_json::to_string(&message)?;

    sqs_client
        .send_message()
        .queue_url(queue_url)
        .message_body(message_str)
        .send()
        .await?;

    Ok(())
}

/// The message we send to the sfs_delete
#[cfg(feature = "sfs_delete")]
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct SFSDeleteMessage {
    /// The ID of the row in email_attachments_sfs
    pub db_id: Uuid,
    /// The ID of the item in SFS
    pub sfs_id: Uuid,
}

#[cfg(test)]
mod test;