Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use super::*;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
#[derive(Clone)]
struct Grants(VerifiedMailboxGrant);
impl CompletedMailboxGrantSource for Grants {
async fn completed_grant(
&self,
_: Uuid,
owner: Uuid,
) -> Result<VerifiedMailboxGrant, InitializationError> {
if owner != self.0.owner {
return Err(InitializationError::InvalidAttempt);
}
Ok(self.0.clone())
}
}
async fn actor(db: &PgPool, email: &str) -> (Uuid, MacroUserIdStr<'static>) {
let id = macro_uuid::generate_uuid_v7();
let macro_id = MacroUserIdStr::try_from(format!("macro|{email}")).unwrap();
sqlx::query!(
"INSERT INTO macro_user (id,username,email,stripe_customer_id) VALUES ($1,$2,$3,$4)",
id,
macro_id.as_ref(),
email,
format!("cus_{id}")
)
.execute(db)
.await
.unwrap();
sqlx::query!(
r#"INSERT INTO "User" (id,email,macro_user_id) VALUES ($1,$2,$3)"#,
macro_id.as_ref(),
email,
id
)
.execute(db)
.await
.unwrap();
(id, macro_id)
}
async fn attempt(db: &PgPool, actor: (Uuid, MacroUserIdStr<'static>)) -> InitializeMailbox {
let id = macro_uuid::generate_uuid_v7();
sqlx::query!("INSERT INTO in_progress_user_link (id,macro_user_id,email_provider,linked_email) VALUES ($1,$2,'OUTLOOK','[email protected]')",id,actor.0)
.execute(db).await.unwrap();
InitializeMailbox {
attempt: id,
actor: actor.1,
actor_fusion_id: actor.0,
force_share: false,
}
}
fn grant(owner: Uuid) -> VerifiedMailboxGrant {
VerifiedMailboxGrant {
scopes: vec![
"User.Read".into(),
"Mail.ReadWrite".into(),
"Mail.Send".into(),
],
calendar_requested: false,
id: macro_uuid::generate_uuid_v7(),
generation: 1,
owner,
email: "[email protected]".into(),
tenant_id: "tenant".into(),
mailbox_id: "mailbox".into(),
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn initialization_is_atomic_idempotent_and_seeds_independent_provider_streams(db: PgPool) {
let actor = actor(&db, "[email protected]").await;
let request = attempt(&db, actor.clone()).await;
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(actor.0)),
);
let link = service.initialize(request.clone()).await.unwrap();
assert!(service.recognizes(&request).await.unwrap());
assert_eq!(service.initialize(request.clone()).await.unwrap(), link);
let row = sqlx::query!("SELECT provider::text AS provider,grant_generation,provider_mailbox_id FROM email_links WHERE id = $1",link).fetch_one(&db).await.unwrap();
assert_eq!(row.provider.as_deref(), Some("OUTLOOK"));
assert_eq!(row.grant_generation, 1);
assert_eq!(row.provider_mailbox_id.as_deref(), Some("mailbox"));
let streams = sqlx::query!(
"SELECT kind FROM email_sync_streams WHERE link_id = $1 ORDER BY kind",
link
)
.fetch_all(&db)
.await
.unwrap();
assert_eq!(
streams
.iter()
.map(|stream| stream.kind.as_str())
.collect::<Vec<_>>(),
vec!["contacts_catalog", "contacts_profile", "folder_catalog"]
);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM email_projection_outbox WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap(),
Some(1)
);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM in_progress_user_link WHERE id = $1",
request.attempt
)
.fetch_one(&db)
.await
.unwrap(),
Some(0)
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn shared_promotion_keeps_one_inbox_and_both_scoped_access_edges(db: PgPool) {
let first = actor(&db, "[email protected]").await;
let second = actor(&db, "[email protected]").await;
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(first.0)),
);
let link = service
.initialize(attempt(&db, first.clone()).await)
.await
.unwrap();
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(second.0)),
);
let mut request = attempt(&db, second.clone()).await;
assert!(matches!(
service.initialize(request.clone()).await,
Err(InitializationError::SharingConfirmation { .. })
));
request.force_share = true;
assert_eq!(service.initialize(request).await.unwrap(), link);
let row = sqlx::query!(
"SELECT macro_id,fusionauth_user_id,sync_generation FROM email_links WHERE id = $1",
link
)
.fetch_one(&db)
.await
.unwrap();
assert_eq!(row.macro_id, "macro|[email protected]");
assert_eq!(row.fusionauth_user_id, second.0.to_string());
assert_eq!(row.sync_generation, 2);
assert_eq!(
sqlx::query_scalar!("SELECT count(*) FROM email_links")
.fetch_one(&db)
.await
.unwrap(),
Some(1)
);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM macro_user_links WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap(),
Some(2)
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn wrong_actor_and_changed_snapshot_cannot_consume_an_attempt(db: PgPool) {
let owner = actor(&db, "[email protected]").await;
let other = actor(&db, "[email protected]").await;
let mut request = attempt(&db, owner.clone()).await;
let grants = grant(owner.0);
let repo = PgMailboxInitialization(db.clone());
let before = repo.inspect(&request, &grants).await.unwrap();
request.actor = other.1;
request.actor_fusion_id = other.0;
assert!(matches!(
repo.commit(
&request,
&grants,
&before,
InitializationDecision::Create {
owner: owner.1.clone()
}
)
.await,
Err(InitializationError::Changed)
));
assert_eq!(
sqlx::query_scalar!("SELECT count(*) FROM email_links")
.fetch_one(&db)
.await
.unwrap(),
Some(0)
);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM in_progress_user_link WHERE id = $1",
request.attempt
)
.fetch_one(&db)
.await
.unwrap(),
Some(1)
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn mixed_provider_connection_limit_is_rechecked_without_blocking_reconnect(db: PgPool) {
let owner = actor(&db, "[email protected]").await;
let req = attempt(&db, owner.clone()).await;
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(owner.0)),
);
let outlook = service.initialize(req.clone()).await.unwrap();
let gmail = Uuid::now_v7();
sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",gmail,owner.1.as_ref(),owner.0.to_string()).execute(&db).await.unwrap();
let reconnect = attempt(&db, owner.clone()).await;
assert_eq!(service.initialize(reconnect).await.unwrap(), outlook);
let req = attempt(&db, owner.clone()).await;
let mut third = grant(owner.0);
third.email = "[email protected]".into();
third.mailbox_id = "third".into();
let service =
MailboxInitializationService::new(PgMailboxInitialization(db.clone()), Grants(third));
assert!(matches!(
service.initialize(req).await,
Err(InitializationError::PaymentRequired)
));
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn gmail_reservation_counts_outlook_and_allows_only_verified_reconnect(db: PgPool) {
let owner = actor(&db, "[email protected]").await;
for (address, provider) in [
("[email protected]", "GMAIL"),
("[email protected]", "OUTLOOK"),
] {
sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,$4,$5::text::email_user_provider_enum)",Uuid::now_v7(),owner.1.as_ref(),owner.0.to_string(),address,provider).execute(&db).await.unwrap();
}
let admission = email::domain::inbox_entitlement::InboxConnectionService(
email::outbound::EmailPgRepo::new(db.clone()),
);
let gmail =
sqlx::query_scalar!("SELECT id FROM email_links WHERE email_address='[email protected]'")
.fetch_one(&db)
.await
.unwrap();
assert!(
admission
.permits_connection(
owner.1.clone(),
false,
email::domain::models::UserProvider::Gmail,
Some(gmail)
)
.await
.unwrap()
);
assert!(
!admission
.permits_connection(
owner.1.clone(),
false,
email::domain::models::UserProvider::Outlook,
Some(gmail)
)
.await
.unwrap()
);
assert!(
!admission
.permits_connection(
owner.1.clone(),
false,
email::domain::models::UserProvider::Gmail,
Some(Uuid::now_v7())
)
.await
.unwrap()
);
let mut tx = db.begin().await.unwrap();
assert!(matches!(
lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await,
Err(InitializationError::PaymentRequired)
));
assert!(matches!(
lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await,
Err(InitializationError::PaymentRequired)
));
lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]")
.await
.unwrap();
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn admission_pause_rejects_new_mailbox_but_preserves_reconnect(db: PgPool) {
let owner = actor(&db, "[email protected]").await;
let request = attempt(&db, owner.clone()).await;
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(owner.0)),
)
.with_connections_enabled(false);
assert!(matches!(
service.initialize(request.clone()).await,
Err(InitializationError::Unavailable)
));
let enabled = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(owner.0)),
);
let link = enabled.initialize(request).await.unwrap();
assert_eq!(
service
.initialize(attempt(&db, owner.clone()).await)
.await
.unwrap(),
link
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn reconnect_resumes_organization_commands_under_the_new_grant(db: PgPool) {
use email::domain::{
mailbox::commands::MailboxCommandRepository,
models::mailbox_action::{MailboxAction, MailboxActionTarget, PendingMailboxState},
ports::EmailRepo,
};
let owner = actor(&db, "[email protected]").await;
let link = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(owner.0)),
)
.initialize(attempt(&db, owner.clone()).await)
.await
.unwrap();
let (thread, message, other) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
sqlx::query!(
"INSERT INTO email_threads(id,link_id) VALUES($1,$2)",
thread,
link
)
.execute(&db)
.await
.unwrap();
for (id, provider_id) in [(message, "outlook-message"), (other, "outlook-other")] {
sqlx::query!(
"INSERT INTO email_messages(id,link_id,thread_id,provider_id) VALUES($1,$2,$3,$4)",
id,
link,
thread,
provider_id
)
.execute(&db)
.await
.unwrap();
}
let target_for = |message_id, provider_id: &str, is_read| MailboxActionTarget {
message_id,
provider_id: Some(provider_id.into()),
pending: PendingMailboxState {
is_read: Some(is_read),
..Default::default()
},
};
let target = |is_read| target_for(message, "outlook-message", is_read);
let repo = email::outbound::EmailPgRepo::new(db.clone());
let retrying = repo
.enqueue_mailbox_action(
link,
owner.1.clone(),
&MailboxAction::Read(true),
&[target(true)],
)
.await
.unwrap();
let queued = repo
.enqueue_mailbox_action(
link,
owner.1.clone(),
&MailboxAction::Read(false),
&[target(false)],
)
.await
.unwrap();
let sync = email::outbound::mailbox_pg::PgMailboxSync::new(db.clone());
let lease = sync.claim_command(Uuid::now_v7()).await.unwrap().unwrap();
assert_eq!(lease.id, retrying);
// An authorization failure releases the lease for a later retry.
sync.release_command(&lease, 300).await.unwrap();
let confirming = repo
.enqueue_mailbox_action(
link,
owner.1.clone(),
&MailboxAction::Read(true),
&[target_for(other, "outlook-other", true)],
)
.await
.unwrap();
sqlx::query!(
"UPDATE email_mailbox_commands SET status = 'confirming' WHERE id = $1",
confirming
)
.execute(&db)
.await
.unwrap();
MailboxInitializationService::new(PgMailboxInitialization(db.clone()), Grants(grant(owner.0)))
.initialize(attempt(&db, owner.clone()).await)
.await
.unwrap();
let generation = sqlx::query_scalar!(
"SELECT sync_generation FROM email_links WHERE id = $1",
link
)
.fetch_one(&db)
.await
.unwrap();
assert_eq!(generation, lease.mailbox.sync_generation + 1);
let commands = sqlx::query!(
"SELECT id,status,generation FROM email_mailbox_commands WHERE link_id = $1 ORDER BY accepted_order",
link
)
.fetch_all(&db)
.await
.unwrap();
assert_eq!(
commands
.iter()
.map(|c| (c.id, c.status.as_str(), c.generation))
.collect::<Vec<_>>(),
vec![
(retrying, "pending", generation),
(queued, "pending", generation),
(confirming, "pending", generation)
]
);
assert_eq!(
sqlx::query_scalar!(
"SELECT command_id FROM email_pending_mailbox_state WHERE message_id = $1",
message
)
.fetch_one(&db)
.await
.unwrap(),
queued,
"the newest accepted intent stays visible across the reconnect"
);
let mut resumed = Vec::new();
for _ in 0..2 {
let lease = sync.claim_command(Uuid::now_v7()).await.unwrap().unwrap();
resumed.push((lease.id, lease.mailbox.sync_generation));
}
resumed.sort();
let mut expected = vec![(retrying, generation), (confirming, generation)];
expected.sort();
assert_eq!(
resumed, expected,
"a confirming command resumes instead of blocking later commands"
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn concurrent_gmail_and_outlook_connections_share_one_remaining_free_slot(db: PgPool) {
let owner = actor(&db, "[email protected]").await;
sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",Uuid::new_v4(),owner.1.as_ref(),owner.0.to_string()).execute(&db).await.unwrap();
let request = attempt(&db, owner.clone()).await;
let service = MailboxInitializationService::new(
PgMailboxInitialization(db.clone()),
Grants(grant(owner.0)),
);
let gmail = async {
let mut tx = db.begin().await.map_err(unavailable)?;
lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await?;
let id = Uuid::new_v4();
sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",id,owner.1.as_ref(),owner.0.to_string()).execute(&mut *tx).await.map_err(unavailable)?;
tx.commit().await.map_err(unavailable)?;
Ok::<_, InitializationError>(id)
};
let (gmail, outlook) = tokio::join!(gmail, service.initialize(request));
assert_ne!(gmail.is_ok(), outlook.is_ok());
let failure = gmail.err().or(outlook.err()).unwrap();
assert!(matches!(failure, InitializationError::PaymentRequired));
let count=sqlx::query_scalar!("SELECT count(*) FROM email_links l WHERE l.macro_id=$1 OR EXISTS(SELECT 1 FROM macro_user_links a WHERE a.link_id=l.id AND a.primary_macro_id=$1)",owner.1.as_ref()).fetch_one(&db).await.unwrap();
assert_eq!(count, Some(2));
}