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
mod telemetry;
use crate::api::context::{ApiContext, AuthorizationService};
use crate::api::folders_query::DssFoldersQueryReader;
use agent_session::outbound::postgres::PgAgentSessionRepo;
use async_graphql::{Data, http::GraphiQLSource};
use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
use axum::{
Router,
body::HttpBody,
extract::{OriginalUri, State},
http::{StatusCode, request::Parts},
response::{Html, IntoResponse, Response},
routing::get,
};
use axum_extra::extract::Cached;
use bots::outbound::pg_bots_repo::PgBotsRepo;
use complete_graph::{GraphqlRequestParts, MAIL_CACHE_PROFILE_HEADER, MailCacheProfile};
use entity_registry::OwnerGrantPolicy;
use entity_registry_db_utils::OwnedEntityRegistrar;
use graphql_soup::email_mutation_thread_loader;
use macro_authorization::{
MacroUserAuthentication, OptionalMacroAuthorizationExtractor, UserOrInternalService,
UserOrInternalServiceAuthorization,
};
use macro_user_id::user_id::MacroUserIdStr;
use uuid::Uuid;
mod websocket;
use websocket::GraphqlWebSocketUpgrade;
const GRAPHQL_PATH: &str = "/soup/graphql";
const GRAPHQL_SUBSCRIPTION_PATH: &str = "/soup/graphql/ws";
pub(crate) fn router() -> Router<ApiContext> {
Router::new()
.route(GRAPHQL_PATH, get(graphiql).post(graphql_handler))
.route(GRAPHQL_SUBSCRIPTION_PATH, get(subscription_handler))
}
async fn graphiql(OriginalUri(uri): OriginalUri) -> Html<String> {
Html(graphiql_source(uri.path()))
}
fn graphiql_source(endpoint: &str) -> String {
let subscription_endpoint = format!("{endpoint}/ws");
GraphiQLSource::build()
.endpoint(endpoint)
.subscription_endpoint(&subscription_endpoint)
.finish()
}
async fn graphql_handler(
State(state): State<ApiContext>,
Cached(auth): Cached<
OptionalMacroAuthorizationExtractor<AuthorizationService, UserOrInternalService>,
>,
request_parts: Parts,
request: GraphQLRequest,
) -> Response {
let acting_user = auth
.authorization
.as_ref()
.and_then(UserOrInternalServiceAuthorization::acting_user);
let mail_profile = MailCacheProfile::from_advertised(
request_parts
.headers
.get(MAIL_CACHE_PROFILE_HEADER)
.and_then(|value| value.to_str().ok()),
);
let result = telemetry::observe(request.into_inner(), acting_user.is_some(), |request| {
let request = graphql_query_context_data(
request,
&state,
acting_user.map(|user| user.macro_user_id.clone()),
acting_user.and_then(|user| user.user_context.organization_id.map(i64::from)),
acting_user.and_then(opaque_viewer_id),
);
state.graphql_soup_schema.execute(
request
.data(mail_profile)
.data(GraphqlRequestParts::new(request_parts)),
)
})
.await;
graphql_response(result)
}
#[tracing::instrument(skip_all, name = "graphql.serialize", fields(response_bytes = tracing::field::Empty))]
fn graphql_response(result: async_graphql::Response) -> Response {
let response = GraphQLResponse::from(result).into_response();
if let Some(bytes) = response.body().size_hint().exact() {
tracing::Span::current().record("response_bytes", bytes);
}
response
}
async fn subscription_handler(
State(state): State<ApiContext>,
Cached(auth): Cached<
OptionalMacroAuthorizationExtractor<AuthorizationService, UserOrInternalService>,
>,
upgrade: GraphqlWebSocketUpgrade,
) -> Response {
let Some(acting_user) = auth
.authorization
.as_ref()
.and_then(UserOrInternalServiceAuthorization::acting_user)
else {
return (
StatusCode::UNAUTHORIZED,
"authentication required for GraphQL Soup subscriptions",
)
.into_response();
};
let macro_user_id = acting_user.macro_user_id.clone();
let organization_id = acting_user.user_context.organization_id.map(i64::from);
let viewer_id = opaque_viewer_id(acting_user);
let schema = state.graphql_soup_schema.clone();
let data = graphql_subscription_context_data(&state, macro_user_id, organization_id, viewer_id);
upgrade.serve(schema, data)
}
/// The viewer's opaque account id (`macro_user.id`, the FusionAuth user id),
/// logged in place of the email-bearing Macro user id.
fn opaque_viewer_id(user: &MacroUserAuthentication) -> Option<Uuid> {
Uuid::parse_str(&user.user_context.fusion_user_id).ok()
}
fn graphql_subscription_context_data(
state: &ApiContext,
user: MacroUserIdStr<'static>,
organization_id: Option<i64>,
viewer_id: Option<Uuid>,
) -> Data {
let mut data = Data::default();
insert_graphql_context_data(&mut data, state, Some(user), organization_id, viewer_id);
data
}
fn graphql_query_context_data(
mut req: async_graphql::Request,
state: &ApiContext,
macro_user_id: Option<MacroUserIdStr<'static>>,
organization_id: Option<i64>,
viewer_id: Option<Uuid>,
) -> async_graphql::Request {
insert_graphql_context_data(
&mut req.data,
state,
macro_user_id,
organization_id,
viewer_id,
);
req
}
fn insert_graphql_context_data(
data: &mut Data,
state: &ApiContext,
macro_user_id: Option<MacroUserIdStr<'static>>,
organization_id: Option<i64>,
viewer_id: Option<Uuid>,
) {
data.insert(state.clone());
let saved_views: std::sync::Arc<dyn saved_views::domain::SavedViewApi> =
std::sync::Arc::new(crate::service::saved_views::service(state.db.clone()));
data.insert(saved_views);
let Some(macro_user_id) = macro_user_id else {
return;
};
let property_reader = complete_graph::PropertiesEntityPropertyReader::new(
state.properties_service.clone(),
state.entity_access_service.clone(),
);
let property_writer = complete_graph::PropertiesEntityPropertyWriter::new(
state.properties_service.clone(),
state.entity_access_service.clone(),
macro_user_id.clone(),
);
let email_content_reader = complete_graph::EmailServiceEmailContentReader::new(
state.soup_router_state.email_service(),
state.entity_access_service.clone(),
);
data.insert(macro_user_id.clone());
data.insert(entity_mutation::EntityMutationActor {
user_id: macro_user_id.clone(),
organization_id,
});
data.insert(favorites::domain::models::FavoritesMutationActor {
user_id: macro_user_id.clone(),
organization_id,
});
data.insert(state.graphql_entity_mutation_service.clone());
data.insert(state.favorites_mutation_service.clone());
data.insert(state.favorites_service.clone());
data.insert(graphql_soup::FoldersQuery::new(DssFoldersQueryReader(
state.projects_state.service.clone(),
)));
data.insert(state.channel_service.clone());
data.insert(state.graphql_initiative_context.clone());
data.insert(state.graphql_database_rows_context.clone());
data.insert(state.graphql_scheduled_action_context.clone());
data.insert(state.graphql_calendar_context.clone());
data.insert(state.graphql_calendar_mutation_context.clone());
data.insert(state.graphql_work_feed_context.clone());
data.insert(state.graphql_registered_work_context.clone());
data.insert(state.graphql_notification_inbox_context.clone());
data.insert(state.graphql_initiative_entity_loader.clone());
data.insert(state.graphql_agent_session_entity_loader.clone());
data.insert(state.graphql_primary_soup_item_loader.clone());
data.insert(graphql_initiative::initiative_loader(
state.graphql_initiative_context.clone(),
macro_user_id.clone(),
));
data.insert(graphql_crm::pipeline_entries_loader(
state.graphql_crm_context.clone(),
macro_user_id.clone(),
));
data.insert(state.graphql_notification_reader.clone());
data.insert(state.soup_router_state.email_service());
data.insert(state.entity_access_service.clone());
data.insert(state.graphql_soup_item_loader.clone());
data.insert(state.agent_session_log_subscriptions.clone());
// Mutation replies must read their committed state from the primary email
// service. Ordinary Soup lists and subscriptions retain their own reader.
data.insert(email_mutation_thread_loader(
state.soup_router_state.email_service(),
));
data.insert(complete_graph::agent_session_bot_loader(PgBotsRepo::new(
state.readonly_db.0.clone(),
)));
// Read right after the session is created and after its subscription
// starts, so the log must hold every committed row: the primary.
data.insert(complete_graph::agent_session_log_loader(
PgAgentSessionRepo::new(
state.db.clone(),
OwnedEntityRegistrar::new(OwnerGrantPolicy::new(PgBotsRepo::new(state.db.clone()))),
),
));
data.insert(complete_graph::entity_properties_loader(
macro_user_id.clone(),
property_reader,
));
data.insert(complete_graph::email_content_loader(
macro_user_id.clone(),
email_content_reader.clone(),
));
data.insert(complete_graph::email_thread_metadata_loader(
macro_user_id.clone(),
viewer_id,
email_content_reader.clone(),
));
data.insert(complete_graph::email_thread_mail_projection_loader(
macro_user_id.clone(),
viewer_id,
email_content_reader,
));
data.insert(complete_graph::EmailFocusContext(
state.email_focus_reader.clone(),
));
data.insert(complete_graph::email_thread_focus_loader(
macro_user_id.clone(),
state.email_focus_reader.clone(),
));
data.insert(complete_graph::entity_favorite_loader(
macro_user_id.clone(),
state.favorites_service.clone(),
));
data.insert(complete_graph::entity_permission_loader(
macro_user_id.clone(),
organization_id,
state.entity_access_service.clone(),
));
data.insert(property_writer);
data.insert(complete_graph::entity_notifications_loader(
macro_user_id,
state.graphql_notification_reader.clone(),
));
// The feed resolver reads the reader directly; the edge goes through
// the request's DataLoader.
data.insert(state.activity_reader.clone());
data.insert(complete_graph::entity_activity_loader(
state.activity_reader.clone(),
));
}
#[cfg(test)]
mod test;