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 std::collections::HashSet;
use std::sync::{Arc, Mutex};
use futures::channel::oneshot;
use entity_access_management::domain::models::EntityAccessManagementError;
use entity_access_management::domain::ports::EntityAccessManagementService;
use entity_registry::{BotFacts, EntityRegistryResult, OwnerGrantPolicy};
use entity_registry_db_utils::OwnedEntityRegistrar;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use macro_event_broker::NoopMacroEventBroker;
use sqlx::PgPool;
use super::*;
use crate::domain::ports::{
ProjectSearchIndexer, ShaCounterPort, UnavailableBulkUploadRequestPort,
UnavailableProjectUploadUrlPort,
};
use crate::domain::service::ProjectServiceImpl;
use crate::outbound::PgProjectRepo;
const OWNER: &str = "macro|[email protected]";
const ROOT_ID: &str = "10000000-0000-0000-0000-000000000001";
const FIRST_CHILD_ID: &str = "10000000-0000-0000-0000-000000000002";
const DOCUMENT_ID: &str = "20000000-0000-0000-0000-000000000001";
const CHAT_ID: &str = "30000000-0000-0000-0000-000000000001";
#[derive(Clone)]
struct NoBots;
impl BotFacts for NoBots {
async fn sponsor(&self, _bot: bot_id::BotId) -> EntityRegistryResult<Option<Owner>> {
Ok(None)
}
}
/// Accepts the side effects of creating and purging projects.
#[derive(Clone, Copy)]
struct AcceptAll;
impl ShaCounterPort for AcceptAll {
async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
Ok(())
}
}
impl ProjectSearchIndexer for AcceptAll {
async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
Ok(())
}
async fn enqueue_document_deletes(
&self,
_documents: Vec<(String, String)>,
) -> anyhow::Result<()> {
Ok(())
}
}
impl EntityAccessManagementService for AcceptAll {
async fn add_entity_to_project(
&self,
_entity_id: &Uuid,
_entity_type: EntityType,
_project_id: &Uuid,
) -> Result<(), EntityAccessManagementError> {
Ok(())
}
async fn remove_entity_from_project(
&self,
_entity_id: &Uuid,
_entity_type: EntityType,
_old_project_id: &Uuid,
) -> Result<(), EntityAccessManagementError> {
Ok(())
}
async fn move_project(
&self,
_project_id: &Uuid,
_old_project_id: Option<&Uuid>,
_new_project_id: Option<&Uuid>,
) -> Result<(), EntityAccessManagementError> {
Ok(())
}
}
type TestProjects = ProjectServiceImpl<
PgProjectRepo<NoBots>,
UnavailableProjectUploadUrlPort,
UnavailableBulkUploadRequestPort,
AcceptAll,
AcceptAll,
AcceptAll,
NoopMacroEventBroker,
>;
fn projects(pool: PgPool) -> Arc<TestProjects> {
Arc::new(ProjectServiceImpl::new(
PgProjectRepo::new(
pool,
OwnedEntityRegistrar::new(OwnerGrantPolicy::new(NoBots)),
),
UnavailableProjectUploadUrlPort,
UnavailableBulkUploadRequestPort,
AcceptAll,
AcceptAll,
AcceptAll,
None,
NoopMacroEventBroker,
))
}
/// Copies documents and chats as rows in the target folder, the way their
/// domains leave a filed copy, and records what it copied.
#[derive(Clone)]
struct FakeContents {
pool: PgPool,
hidden: HashSet<&'static str>,
can_add_to_parent: bool,
/// The source whose copy fails, once another copy has finished.
failing: Option<&'static str>,
first_copy_done: Arc<Mutex<Option<oneshot::Sender<()>>>>,
first_copy_waiter: Arc<Mutex<Option<oneshot::Receiver<()>>>>,
copied: Arc<Mutex<Vec<(String, String, String)>>>,
}
impl FakeContents {
fn new(pool: PgPool) -> Self {
let (done, waiter) = oneshot::channel();
Self {
pool,
hidden: HashSet::new(),
can_add_to_parent: true,
failing: None,
first_copy_done: Arc::new(Mutex::new(Some(done))),
first_copy_waiter: Arc::new(Mutex::new(Some(waiter))),
copied: Arc::default(),
}
}
/// `(source id, copy's folder, name)` per copy, sorted.
fn copied(&self) -> Vec<(String, String, String)> {
let mut copied = self.copied.lock().unwrap().clone();
copied.sort();
copied
}
}
impl ProjectContentCopier for FakeContents {
async fn view_receipt(
&self,
entity: &Entity<'static>,
) -> Result<Option<EntityAccessReceipt<ViewAccessLevel>>, EntityMutationErrorCode> {
if self.hidden.contains(entity.entity_id.as_ref()) {
return Ok(None);
}
Ok(Some(
EntityAccessReceipt::dangerously_assert_authenticated_user(
MacroUserIdStr::try_from(OWNER.to_string()).unwrap(),
&entity.entity_id,
entity.entity_type,
),
))
}
async fn can_add_to_project(&self, _project_id: &str) -> Result<bool, EntityMutationErrorCode> {
Ok(self.can_add_to_parent)
}
async fn copy_into_project(
&self,
receipt: EntityAccessReceipt<ViewAccessLevel>,
name: String,
project_id: &str,
) -> Result<Entity<'static>, EntityMutationErrorCode> {
let source = receipt.entity();
if self.failing == Some(source.entity_id.as_str()) {
let waiter = self.first_copy_waiter.lock().unwrap().take();
if let Some(waiter) = waiter {
waiter.await.unwrap();
}
return Err(EntityMutationErrorCode::internal(rootcause::report!(
"copy failed".to_string()
)));
}
let copy_id = Uuid::now_v7();
match source.entity_type {
EntityType::Document => {
sqlx::query!(
r#"INSERT INTO "Document" (id, name, owner, "projectId") VALUES ($1, $2, $3, $4)"#,
copy_id.to_string(),
name,
OWNER,
project_id,
)
.execute(&self.pool)
.await
.unwrap();
}
_ => {
sqlx::query!(
r#"INSERT INTO "Chat" (id, name, "userId", "projectId") VALUES ($1, $2, $3, $4)"#,
copy_id.to_string(),
name,
OWNER,
project_id,
)
.execute(&self.pool)
.await
.unwrap();
}
}
sqlx::query!(
r#"
INSERT INTO entity (id, entity_type, owner_type, owner_id)
VALUES ($1, $2, 'user', $3)
"#,
copy_id,
source.entity_type.to_string(),
OWNER,
)
.execute(&self.pool)
.await
.unwrap();
self.copied
.lock()
.unwrap()
.push((source.entity_id.clone(), project_id.to_string(), name));
let done = self.first_copy_done.lock().unwrap().take();
if let Some(done) = done {
let _ = done.send(());
}
Ok(source.entity_type.with_entity_string(copy_id.to_string()))
}
}
async fn duplicate(
duplicator: &ProjectDuplicator<TestProjects, FakeContents>,
project_id: &str,
display_name: Option<&str>,
) -> Result<Vec<EntityMutationEffect>, EntityMutationErrorCode> {
let owner = MacroUserIdStr::try_from(OWNER.to_string()).unwrap();
duplicator
.duplicate_entity(
EntityType::Project.with_entity_string(project_id.to_string()),
EntityAccessReceipt::dangerously_assert_authenticated_user(
owner.clone(),
project_id,
EntityType::Project,
),
owner,
display_name.map(str::to_string),
)
.await
}
/// The live folders directly inside `parent_id` (or at the top level), as
/// `(id, name, owner)`.
async fn child_folders(pool: &PgPool, parent_id: Option<&str>) -> Vec<(String, String, String)> {
sqlx::query!(
r#"
SELECT id, name, "userId" AS user_id
FROM "Project"
WHERE "parentId" IS NOT DISTINCT FROM $1 AND "deletedAt" IS NULL
ORDER BY name
"#,
parent_id,
)
.map(|row| (row.id, row.name, row.user_id))
.fetch_all(pool)
.await
.unwrap()
}
fn copy_id(effects: &[EntityMutationEffect]) -> String {
match effects {
[EntityMutationEffect::Updated(copy)] if copy.entity_type == EntityType::Project => {
copy.entity_id.to_string()
}
other => panic!("expected one updated project, got {other:?}"),
}
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn copies_subfolders_documents_and_chats_into_a_new_tree(pool: PgPool) {
let contents = FakeContents::new(pool.clone());
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let effects = duplicate(&duplicator, ROOT_ID, None).await.unwrap();
let copy = copy_id(&effects);
let top_level = child_folders(&pool, None).await;
assert!(top_level.contains(&(copy.clone(), "Root copy".to_string(), OWNER.to_string())));
let first_child = child_folders(&pool, Some(©)).await;
assert_eq!(first_child.len(), 1);
assert_eq!(first_child[0].1, "First child");
assert_eq!(first_child[0].2, OWNER);
let grandchild = child_folders(&pool, Some(&first_child[0].0)).await;
assert_eq!(grandchild.len(), 1);
assert_eq!(grandchild[0].1, "Grandchild");
assert!(
child_folders(&pool, Some(&grandchild[0].0))
.await
.is_empty()
);
assert_eq!(
contents.copied(),
vec![
(
DOCUMENT_ID.to_string(),
copy.clone(),
"Document".to_string()
),
(CHAT_ID.to_string(), copy.clone(), "Chat".to_string()),
]
);
// The source tree is untouched.
assert_eq!(child_folders(&pool, Some(ROOT_ID)).await.len(), 1);
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn places_the_copy_beside_the_source_only_when_the_user_can_add_there(pool: PgPool) {
let beside = ProjectDuplicator::new(projects(pool.clone()), FakeContents::new(pool.clone()));
let effects = duplicate(&beside, FIRST_CHILD_ID, Some("Renamed"))
.await
.unwrap();
let copy = copy_id(&effects);
let in_root = child_folders(&pool, Some(ROOT_ID)).await;
assert!(in_root.contains(&(copy.clone(), "Renamed".to_string(), OWNER.to_string())));
assert_eq!(child_folders(&pool, Some(©)).await[0].1, "Grandchild");
let mut no_access_to_parent = FakeContents::new(pool.clone());
no_access_to_parent.can_add_to_parent = false;
let top_level = ProjectDuplicator::new(projects(pool.clone()), no_access_to_parent);
let effects = duplicate(&top_level, FIRST_CHILD_ID, None).await.unwrap();
let copy = copy_id(&effects);
assert!(child_folders(&pool, None).await.contains(&(
copy,
"First child copy".to_string(),
OWNER.to_string()
)));
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn leaves_email_threads_filed_in_the_source(pool: PgPool) {
let link_id = Uuid::now_v7();
let thread_id = Uuid::now_v7();
sqlx::query!(
r#"
INSERT INTO email_links (id, macro_id, fusionauth_user_id, email_address, provider)
VALUES ($1, $2, 'fusionauth-owner', '[email protected]', 'GMAIL')
"#,
link_id,
OWNER,
)
.execute(&pool)
.await
.unwrap();
sqlx::query!(
r#"INSERT INTO email_threads (id, link_id, project_id) VALUES ($1, $2, $3)"#,
thread_id,
link_id,
ROOT_ID,
)
.execute(&pool)
.await
.unwrap();
let contents = FakeContents::new(pool.clone());
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let effects = duplicate(&duplicator, ROOT_ID, None).await.unwrap();
let copy = copy_id(&effects);
let thread_folders = sqlx::query_scalar!(
r#"SELECT project_id FROM email_threads WHERE link_id = $1"#,
link_id,
)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(thread_folders, vec![Some(ROOT_ID.to_string())]);
assert!(
contents
.copied()
.iter()
.all(|(source, folder, _)| *source != thread_id.to_string() && *folder == copy)
);
assert_eq!(contents.copied().len(), 2);
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn skips_entries_the_user_cannot_view_with_their_contents(pool: PgPool) {
let mut contents = FakeContents::new(pool.clone());
contents.hidden = HashSet::from([FIRST_CHILD_ID, DOCUMENT_ID]);
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let effects = duplicate(&duplicator, ROOT_ID, None).await.unwrap();
let copy = copy_id(&effects);
assert!(child_folders(&pool, Some(©)).await.is_empty());
assert_eq!(
contents.copied(),
vec![(CHAT_ID.to_string(), copy, "Chat".to_string())]
);
let grandchildren = sqlx::query_scalar!(
r#"SELECT COUNT(*) AS "count!" FROM "Project" WHERE name = 'Grandchild'"#
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(grandchildren, 1);
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn refuses_a_tree_over_the_limit_without_creating_anything(pool: PgPool) {
// Two subfolders, a document, and a chat are already in the tree.
sqlx::query!(
r#"
INSERT INTO "Document" (id, name, owner, "projectId")
SELECT gen_random_uuid()::text, 'Bulk ' || n, $1, $2
FROM generate_series(1, 97) AS n
"#,
OWNER,
FIRST_CHILD_ID,
)
.execute(&pool)
.await
.unwrap();
let projects_before = sqlx::query_scalar!(r#"SELECT COUNT(*) AS "count!" FROM "Project""#)
.fetch_one(&pool)
.await
.unwrap();
let contents = FakeContents::new(pool.clone());
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let error = duplicate(&duplicator, ROOT_ID, None).await.unwrap_err();
assert!(matches!(error, EntityMutationErrorCode::InvalidInput(_)));
let projects_after = sqlx::query_scalar!(r#"SELECT COUNT(*) AS "count!" FROM "Project""#)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(projects_after, projects_before);
assert!(contents.copied().is_empty());
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn duplicates_a_tree_at_the_limit(pool: PgPool) {
sqlx::query!(
r#"
INSERT INTO "Document" (id, name, owner, "projectId")
SELECT gen_random_uuid()::text, 'Bulk ' || n, $1, $2
FROM generate_series(1, 96) AS n
"#,
OWNER,
FIRST_CHILD_ID,
)
.execute(&pool)
.await
.unwrap();
let contents = FakeContents::new(pool.clone());
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
duplicate(&duplicator, ROOT_ID, None).await.unwrap();
assert_eq!(contents.copied().len(), 98);
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn a_failed_copy_discards_everything_already_copied(pool: PgPool) {
let projects_before = sqlx::query_scalar!(r#"SELECT COUNT(*) AS "count!" FROM "Project""#)
.fetch_one(&pool)
.await
.unwrap();
let mut contents = FakeContents::new(pool.clone());
contents.failing = Some(CHAT_ID);
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let error = duplicate(&duplicator, ROOT_ID, None).await.unwrap_err();
assert!(matches!(error, EntityMutationErrorCode::Internal(_)));
// The document copied before the chat failed went with the folder copy.
let copied = contents.copied();
assert_eq!(copied.len(), 1);
assert_eq!(copied[0].0, DOCUMENT_ID);
let document_copy_rows = sqlx::query_scalar!(
r#"SELECT COUNT(*) AS "count!" FROM "Document" WHERE name = 'Document'"#
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(document_copy_rows, 1);
let projects_after = sqlx::query_scalar!(r#"SELECT COUNT(*) AS "count!" FROM "Project""#)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(projects_after, projects_before);
let copy_entities = sqlx::query_scalar!(
r#"
SELECT COUNT(*) AS "count!"
FROM entity
WHERE owner_id = $1 AND created_at > NOW() - INTERVAL '1 hour'
"#,
OWNER,
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(copy_entities, 0);
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("projects_test_data"))
)]
async fn refuses_a_deleted_project(pool: PgPool) {
let contents = FakeContents::new(pool.clone());
let duplicator = ProjectDuplicator::new(projects(pool.clone()), contents.clone());
let error = duplicate(&duplicator, "10000000-0000-0000-0000-000000000009", None)
.await
.unwrap_err();
assert!(matches!(error, EntityMutationErrorCode::InvalidInput(_)));
assert!(contents.copied().is_empty());
}