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.

10.3 KB
Raw Blame
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;