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.

17.5 KB
Raw Blame
use super::*;
use crate::domain::mailbox::settings::*;
use email_api_client::domain::models::EmailApiError;
use macro_user_id::user_id::MacroUserIdStr;
use models_email::service::{label::Label, link::UserProvider};

#[cfg(test)]
mod test;

async fn authorized(
    tx: &mut sqlx::PgConnection,
    actor: &MacroUserIdStr<'_>,
    link: Uuid,
) -> Result<SettingsMailbox, MailboxError> {
    let row = sqlx::query!(r#"SELECT sync_generation,grant_generation,provider::text AS "provider!" FROM email_links l
        WHERE l.id=$1 AND l.is_sync_active AND l.disconnect_requested_at IS NULL
        AND (l.macro_id=$2 OR EXISTS(SELECT 1 FROM macro_user_links u WHERE u.link_id=l.id AND u.primary_macro_id=$2)) FOR UPDATE"#,link,actor.as_ref())
        .fetch_optional(tx).await.map_err(db_error)?.ok_or(EmailApiError::NotFound)?;
    Ok(SettingsMailbox {
        key: MailboxKey {
            link_id: link,
            sync_generation: row.sync_generation,
            grant_generation: row.grant_generation,
        },
        provider: match row.provider.as_str() {
            "OUTLOOK" => UserProvider::Outlook,
            "GMAIL" => UserProvider::Gmail,
            _ => return Err(MailboxError::Persistence),
        },
    })
}
async fn guard(tx: &mut sqlx::PgConnection, lease: &SettingsLease) -> Result<(), MailboxError> {
    let valid = sqlx::query!(
        r#"SELECT s.id FROM email_links l JOIN email_mailbox_settings_work s ON s.link_id=l.id
        WHERE l.id=$1 AND l.sync_generation=$2 AND l.grant_generation=$3 AND l.is_sync_active AND l.disconnect_requested_at IS NULL
        AND s.id=$4 AND s.lease_id=$5 AND s.revision=$6 AND s.lease_until>now() FOR UPDATE OF l,s"#,
        lease.mailbox.key.link_id,
        lease.mailbox.key.sync_generation,
        lease.mailbox.key.grant_generation,
        lease.id,
        lease.lease_id,
        lease.revision
    )
    .fetch_optional(tx)
    .await
    .map_err(db_error)?;
    if valid.is_none() {
        return Err(MailboxError::Stale);
    }
    Ok(())
}
async fn upsert_label(
    tx: &mut sqlx::PgConnection,
    mut label: Label,
) -> Result<Label, MailboxError> {
    let row = sqlx::query!(r#"INSERT INTO email_labels(id,link_id,provider_label_id,name,type)
        VALUES($1,$2,$3,$4,'User') ON CONFLICT(link_id,provider_label_id) DO UPDATE SET name=EXCLUDED.name RETURNING id,created_at"#,
        macro_uuid::generate_uuid_v7(),label.link_id,label.provider_label_id,label.name).fetch_one(tx).await.map_err(db_error)?;
    label.id = Some(row.id);
    label.created_at = row.created_at;
    Ok(label)
}
async fn changed(tx: &mut sqlx::PgConnection, mailbox: MailboxKey) -> Result<(), MailboxError> {
    sqlx::query!(r#"INSERT INTO email_projection_outbox(id,link_id,generation,payload) VALUES($1,$2,$3,'{"kind":"link_changed"}')"#,
        macro_uuid::generate_uuid_v7(),mailbox.link_id,mailbox.sync_generation).execute(tx).await.map_err(db_error)?;
    Ok(())
}

impl MailboxSettingsRepository for PgMailboxSync {
    async fn accessible(
        &self,
        actor: &MacroUserIdStr<'_>,
        link: Uuid,
    ) -> Result<SettingsMailbox, MailboxError> {
        authorized(
            &mut *self.db.acquire().await.map_err(db_error)?,
            actor,
            link,
        )
        .await
    }
    async fn store_label(
        &self,
        actor: &MacroUserIdStr<'_>,
        mailbox: SettingsMailbox,
        label: Label,
    ) -> Result<Label, MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        if authorized(&mut tx, actor, mailbox.key.link_id).await?.key != mailbox.key {
            return Err(MailboxError::Stale);
        }
        let deleting=sqlx::query_scalar!("SELECT EXISTS(SELECT 1 FROM email_mailbox_settings_work WHERE link_id=$1 AND kind='delete_label' AND resource_key=$2 AND completed_revision<revision) AS \"exists!\"",mailbox.key.link_id,label.provider_label_id)
            .fetch_one(&mut *tx).await.map_err(db_error)?;
        if deleting {
            return Err(EmailApiError::Conflict.into());
        }
        let label = upsert_label(&mut tx, label).await?;
        changed(&mut tx, mailbox.key).await?;
        tx.commit().await.map_err(db_error)?;
        Ok(label)
    }
    async fn queue_label_creation(
        &self,
        actor: &MacroUserIdStr<'_>,
        mailbox: SettingsMailbox,
        name: &str,
    ) -> Result<Label, MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        if authorized(&mut tx, actor, mailbox.key.link_id).await?.key != mailbox.key {
            return Err(MailboxError::Stale);
        }
        let deleting = sqlx::query_scalar!("SELECT EXISTS(SELECT 1 FROM email_mailbox_settings_work WHERE link_id=$1 AND kind='delete_label' AND resource_key=$2 AND completed_revision<revision) AS \"exists!\"", mailbox.key.link_id, name)
            .fetch_one(&mut *tx).await.map_err(db_error)?;
        if deleting {
            return Err(EmailApiError::Conflict.into());
        }
        let existed = sqlx::query_scalar!("SELECT EXISTS(SELECT 1 FROM email_labels WHERE link_id=$1 AND provider_label_id=$2) AS \"exists!\"", mailbox.key.link_id, name)
            .fetch_one(&mut *tx).await.map_err(db_error)?;
        let label = upsert_label(
            &mut tx,
            Label {
                id: None,
                link_id: mailbox.key.link_id,
                provider_label_id: name.into(),
                name: Some(name.into()),
                created_at: chrono::Utc::now(),
                message_list_visibility: None,
                label_list_visibility: None,
                type_: Some(models_email::service::label::LabelType::User),
            },
        )
        .await?;
        if !existed {
            sqlx::query!(r#"INSERT INTO email_mailbox_settings_work(id,link_id,kind,resource_key)
                VALUES($1,$2,'create_label',$3) ON CONFLICT(link_id,kind,resource_key)
                DO UPDATE SET revision=email_mailbox_settings_work.revision+1,next_run_at=now(),failure=NULL"#,
                macro_uuid::generate_uuid_v7(),mailbox.key.link_id,name).execute(&mut *tx).await.map_err(db_error)?;
            changed(&mut tx, mailbox.key).await?;
        }
        tx.commit().await.map_err(db_error)?;
        Ok(label)
    }
    async fn commit_created_label(
        &self,
        lease: &SettingsLease,
        label: Label,
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        guard(&mut tx, lease).await?;
        if lease.kind != "create_label"
            || label.link_id != lease.mailbox.key.link_id
            || label.provider_label_id != lease.resource
        {
            return Err(MailboxError::Persistence);
        }
        upsert_label(&mut tx, label).await?;
        sqlx::query!("UPDATE email_mailbox_settings_work SET completed_revision=revision,lease_id=NULL,lease_until=NULL,failure=NULL WHERE id=$1",lease.id)
            .execute(&mut *tx).await.map_err(db_error)?;
        changed(&mut tx, lease.mailbox.key).await?;
        tx.commit().await.map_err(db_error)
    }
    async fn delete_label(
        &self,
        actor: &MacroUserIdStr<'_>,
        link: Uuid,
        label: Uuid,
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        let mailbox = authorized(&mut tx, actor, link).await?;
        let row = sqlx::query!(
            "SELECT provider_label_id FROM email_labels WHERE id=$1 AND link_id=$2 AND type='User'",
            label,
            link
        )
        .fetch_optional(&mut *tx)
        .await
        .map_err(db_error)?
        .ok_or(EmailApiError::NotFound)?;
        sqlx::query!(r#"INSERT INTO email_mailbox_settings_work(id,link_id,kind,resource_key) VALUES($1,$2,'delete_label',$3)
            ON CONFLICT(link_id,kind,resource_key) DO UPDATE SET revision=email_mailbox_settings_work.revision+1,next_run_at=now(),failure=NULL"#,
            macro_uuid::generate_uuid_v7(),link,row.provider_label_id).execute(&mut *tx).await.map_err(db_error)?;
        // Invalidate delayed creation commits. Keep an active lease until it
        // expires so deletion follows any already-started provider request.
        sqlx::query!("UPDATE email_mailbox_settings_work SET revision=revision+1,completed_revision=revision+1 WHERE link_id=$1 AND kind='create_label' AND resource_key=$2 AND completed_revision<revision",link,row.provider_label_id)
            .execute(&mut *tx).await.map_err(db_error)?;
        // Retain the catalog row until remote cleanup is confirmed. Message
        // assignments are removed immediately and suppressed during cleanup.
        sqlx::query!("DELETE FROM email_message_labels WHERE label_id=$1", label)
            .execute(&mut *tx)
            .await
            .map_err(db_error)?;
        changed(&mut tx, mailbox.key).await?;
        tx.commit().await.map_err(db_error)
    }
    async fn sender_block(
        &self,
        actor: &MacroUserIdStr<'_>,
        link: Uuid,
        sender: &str,
        blocked: bool,
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        let mailbox = authorized(&mut tx, actor, link).await?;
        super::super::email_pg_repo::sender_policy::enqueue(&mut tx, link, sender, blocked)
            .await
            .map_err(db_error)?;
        changed(&mut tx, mailbox.key).await?;
        tx.commit().await.map_err(db_error)
    }
    async fn sender_intents(
        &self,
        mailbox: SettingsMailbox,
    ) -> Result<Vec<SenderRuleIntent>, MailboxError> {
        Ok(sqlx::query!("SELECT id,resource_key,desired,revision>completed_revision AS \"pending!\" FROM email_mailbox_settings_work WHERE link_id=$1 AND kind='sender_block'",mailbox.key.link_id)
            .fetch_all(&self.db).await.map_err(db_error)?.into_iter().map(|r|SenderRuleIntent {id:r.id,sender:r.resource_key,desired:r.desired,pending:r.pending}).collect())
    }
    async fn pending_operations(
        &self,
        mailbox: SettingsMailbox,
    ) -> Result<Vec<MailboxSettingsOperation>, MailboxError> {
        let rows=sqlx::query!(r#"SELECT s.id,s.kind,s.resource_key,s.desired,s.failure IS NOT NULL AS "failed!"
            FROM email_mailbox_settings_work s JOIN email_links l ON l.id=s.link_id
            WHERE l.id=$1 AND l.sync_generation=$2 AND l.grant_generation=$3
                AND l.is_sync_active AND l.disconnect_requested_at IS NULL
                AND s.kind<>'catalog' AND s.completed_revision<s.revision ORDER BY s.kind,s.resource_key"#,
            mailbox.key.link_id,mailbox.key.sync_generation,mailbox.key.grant_generation).fetch_all(&self.db).await.map_err(db_error)?;
        rows.into_iter()
            .map(|r| {
                Ok(MailboxSettingsOperation {
                    id: r.id,
                    kind: match r.kind.as_str() {
                        "create_label" => MailboxSettingsChange::CreateLabel,
                        "delete_label" => MailboxSettingsChange::DeleteLabel,
                        "sender_block" => MailboxSettingsChange::SenderBlock,
                        _ => return Err(MailboxError::Persistence),
                    },
                    resource: r.resource_key,
                    enabled: r.desired,
                    needs_attention: r.failed,
                })
            })
            .collect()
    }
    async fn claim_settings(
        &self,
        lease_id: Uuid,
        outlook_sync: bool,
        outlook_writes: bool,
    ) -> Result<Option<SettingsLease>, MailboxError> {
        let row=sqlx::query!(r#"WITH candidate AS (
            SELECT s.id FROM email_links l JOIN email_mailbox_settings_work s ON s.link_id=l.id
            WHERE (l.provider<>'OUTLOOK' OR (s.kind='catalog' AND $2) OR (s.kind<>'catalog' AND $3))
            AND l.is_sync_active AND l.disconnect_requested_at IS NULL AND s.next_run_at<=now() AND (s.kind='catalog' OR s.revision>s.completed_revision)
            AND (s.lease_until IS NULL OR s.lease_until<now())
            AND (s.kind<>'delete_label' OR NOT EXISTS(SELECT 1 FROM email_mailbox_commands c
                WHERE c.link_id=s.link_id AND c.generation=l.sync_generation AND c.status IN ('pending','running','confirming')
                AND c.intent->>'kind'='category' AND c.intent->'value'->>'name'=s.resource_key))
            AND NOT EXISTS(SELECT 1 FROM email_mailbox_settings_work busy WHERE busy.link_id=l.id AND busy.lease_until>now())
            ORDER BY s.next_run_at,s.id LIMIT 1 FOR UPDATE OF l,s SKIP LOCKED
        ) UPDATE email_mailbox_settings_work s SET lease_id=$1,lease_until=now()+interval '3 minutes',attempts=attempts+1
        FROM candidate c,email_links l WHERE s.id=c.id AND l.id=s.link_id
        RETURNING s.id,s.link_id,s.revision,s.kind,s.resource_key,s.desired,l.sync_generation,l.grant_generation,l.provider::text AS "provider!""#,lease_id,outlook_sync,outlook_writes)
            .fetch_optional(&self.db).await.map_err(db_error)?;
        row.map(|r| {
            Ok(SettingsLease {
                id: r.id,
                lease_id,
                revision: r.revision,
                kind: r.kind,
                resource: r.resource_key,
                desired: r.desired,
                mailbox: SettingsMailbox {
                    key: MailboxKey {
                        link_id: r.link_id,
                        sync_generation: r.sync_generation,
                        grant_generation: r.grant_generation,
                    },
                    provider: match r.provider.as_str() {
                        "GMAIL" => UserProvider::Gmail,
                        "OUTLOOK" => UserProvider::Outlook,
                        _ => return Err(MailboxError::Persistence),
                    },
                },
            })
        })
        .transpose()
    }
    async fn renew_settings(&self, lease: &SettingsLease) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        guard(&mut tx, lease).await?;
        sqlx::query!("UPDATE email_mailbox_settings_work SET lease_until=now()+interval '3 minutes' WHERE id=$1",lease.id).execute(&mut *tx).await.map_err(db_error)?;
        tx.commit().await.map_err(db_error)
    }
    async fn commit_labels(
        &self,
        lease: &SettingsLease,
        labels: &[Label],
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        guard(&mut tx, lease).await?;
        let deleting=sqlx::query_scalar!("SELECT resource_key FROM email_mailbox_settings_work WHERE link_id=$1 AND kind='delete_label' AND completed_revision<revision",lease.mailbox.key.link_id)
            .fetch_all(&mut *tx).await.map_err(db_error)?;
        let creating=sqlx::query_scalar!("SELECT resource_key FROM email_mailbox_settings_work WHERE link_id=$1 AND kind='create_label' AND completed_revision<revision",lease.mailbox.key.link_id)
            .fetch_all(&mut *tx).await.map_err(db_error)?;
        let mut names = creating;
        for label in labels
            .iter()
            .filter(|l| !deleting.contains(&l.provider_label_id))
        {
            names.push(label.provider_label_id.clone());
            upsert_label(&mut tx, label.clone()).await?;
        }
        sqlx::query!(r#"DELETE FROM email_labels l WHERE l.link_id=$1 AND l.type='User' AND NOT(l.provider_label_id=ANY($2))
            AND NOT EXISTS(SELECT 1 FROM email_message_labels m WHERE m.label_id=l.id)
            AND NOT(l.provider_label_id=ANY($3))"#,lease.mailbox.key.link_id,&names,&deleting).execute(&mut *tx).await.map_err(db_error)?;
        changed(&mut tx, lease.mailbox.key).await?;
        tx.commit().await.map_err(db_error)
    }
    async fn reconcile_settings_message(
        &self,
        lease: &SettingsLease,
        message: &ProviderId,
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        guard(&mut tx, lease).await?;
        sqlx::query!(r#"INSERT INTO email_message_reconciliation(link_id,generation,provider_id,is_import) VALUES($1,$2,$3,false)
            ON CONFLICT(link_id,generation,provider_id) DO UPDATE SET revision=email_message_reconciliation.revision+1,available_at=now()"#,
            lease.mailbox.key.link_id,lease.mailbox.key.sync_generation,message.as_str()).execute(&mut *tx).await.map_err(db_error)?;
        tx.commit().await.map_err(db_error)
    }
    async fn finish_settings(
        &self,
        lease: &SettingsLease,
        complete: bool,
        delay: u32,
        failure: Option<&str>,
    ) -> Result<(), MailboxError> {
        let mut tx = self.db.begin().await.map_err(db_error)?;
        guard(&mut tx, lease).await?;
        if complete && lease.kind == "delete_label" {
            sqlx::query!("DELETE FROM email_message_labels m USING email_labels l WHERE m.label_id=l.id AND l.link_id=$1 AND l.provider_label_id=$2",lease.mailbox.key.link_id,lease.resource)
                .execute(&mut *tx).await.map_err(db_error)?;
            sqlx::query!(
                "DELETE FROM email_labels WHERE link_id=$1 AND provider_label_id=$2",
                lease.mailbox.key.link_id,
                lease.resource
            )
            .execute(&mut *tx)
            .await
            .map_err(db_error)?;
        }
        sqlx::query!(r#"UPDATE email_mailbox_settings_work SET completed_revision=CASE WHEN $2 THEN revision ELSE completed_revision END,
            next_run_at=now()+make_interval(secs=>$3),lease_id=NULL,lease_until=NULL,failure=$4 WHERE id=$1"#,lease.id,complete,f64::from(delay),failure)
            .execute(&mut *tx).await.map_err(db_error)?;
        if complete {
            changed(&mut tx, lease.mailbox.key).await?;
        }
        tx.commit().await.map_err(db_error)
    }
}