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.1 KB
Raw Blame
use std::sync::{Arc, Mutex};

use ::attention_feed::{
    domain::{
        models::{
            CandidateKeying, DoneReceipt, FeedError, FeedKey, FeedPosition, FeedRevision,
            FeedTrigger, FeedViewer,
        },
        ports::FeedTriggers,
    },
    inbound::viewers::FeedViewerResolver,
};
use ::work_feed::domain::models::{
    WorkFeedChange, WorkFeedDoneOutcome, WorkFeedDoneTarget, WorkFeedEntry, WorkFeedItem,
    WorkFeedItemState, WorkFeedItemType, WorkFeedMode, WorkFeedPage, WorkFeedPrimaryReason,
    WorkFeedQuery, WorkFeedScope, WorkFeedStack, WorkFeedStackKind,
};
use async_graphql::futures_util::{StreamExt as _, future::BoxFuture, pin_mut};
use entity_access::domain::models::{EntityAccessReceipt, MemberTeamRole};
use model_notifications::NotifEvent;
use notification::domain::models::{NotificationState, UserNotificationRow};
use soup::domain::models::SoupProjectionHydration;

use super::*;
use crate::{WorkFeedGraphqlContext, WorkFeedGraphqlService};

const DOC_ID: Uuid = Uuid::from_u128(0xD0C);

fn at(minute: u32) -> chrono::DateTime<chrono::Utc> {
    use chrono::TimeZone;
    chrono::Utc
        .with_ymd_and_hms(2024, 6, 1, 10, minute, 0)
        .unwrap()
}

fn doc_key() -> FeedKey {
    FeedKey::new(ModelEntityType::Document.with_entity_string(DOC_ID.to_string()))
}

fn comment(id: u128, minute: u32) -> Arc<UserNotificationRow<NotifEvent>> {
    let metadata: NotifEvent = serde_json::from_value(serde_json::json!({
        "tag": "commented_on_document",
        "content": {
            "documentName": "Doc",
            "owner": VALID_USER_ID,
            "commentId": Uuid::from_u128(id),
            "threadId": Uuid::from_u128(id),
            "text": "looks good",
        },
    }))
    .unwrap();
    Arc::new(UserNotificationRow {
        owner_id: MacroUserIdStr::parse_from_str(VALID_USER_ID).unwrap(),
        notification_id: Uuid::from_u128(id),
        notification_event_type: "commented_on_document".to_string(),
        entity: doc_key().entity().clone(),
        sent: true,
        state: NotificationState::Unseen,
        created_at: at(minute),
        viewed_at: None,
        updated_at: at(minute),
        deleted_at: None,
        notification_metadata: metadata,
        sender_id: None,
    })
}

fn doc_entry() -> WorkFeedEntry<SoupProjectionHydration> {
    let notifications = vec![comment(2, 7), comment(1, 5)];
    WorkFeedEntry {
        sort_at: at(9),
        item: WorkFeedItem {
            key: doc_key(),
            entity: SoupProjectionHydration {
                sort_key: None,
                item: soup_document(DOC_ID),
                document_server_facts: None,
            },
            state: WorkFeedItemState::Unseen,
            attention_at: Some(at(7)),
            touched_at: Some(at(9)),
            stacks: vec![WorkFeedStack {
                kind: WorkFeedStackKind::Comments,
                thread_id: None,
                notifications: notifications.clone(),
            }],
            notifications,
            primary: WorkFeedPrimaryReason::OwnWork,
        },
    }
}

#[derive(Default)]
struct RecordingWorkFeedService {
    pages: Mutex<Vec<(FeedViewer, WorkFeedQuery)>>,
    recomputes: Mutex<Vec<(WorkFeedScope, Vec<FeedKey>)>>,
    dones: Mutex<Vec<Vec<WorkFeedDoneTarget>>>,
    undos: Mutex<Vec<(WorkFeedScope, DoneReceipt)>>,
}

/// Shares the recording service between the schema and the assertions.
struct Recording(Arc<RecordingWorkFeedService>);

impl WorkFeedGraphqlService for Recording {
    fn page(
        &self,
        viewer: FeedViewer,
        query: WorkFeedQuery,
    ) -> BoxFuture<'_, Result<WorkFeedPage<SoupProjectionHydration>, FeedError>> {
        self.0.pages.lock().unwrap().push((viewer, query));
        Box::pin(async {
            Ok(WorkFeedPage {
                entries: vec![doc_entry()],
                next: Some(FeedPosition {
                    sort_at: at(9),
                    entity_id: DOC_ID.to_string(),
                }),
            })
        })
    }

    fn recompute(
        &self,
        _viewer: FeedViewer,
        scope: WorkFeedScope,
        keys: Vec<FeedKey>,
    ) -> BoxFuture<'_, Result<Vec<WorkFeedChange<SoupProjectionHydration>>, FeedError>> {
        self.0
            .recomputes
            .lock()
            .unwrap()
            .push((scope, keys.clone()));
        Box::pin(async move {
            Ok(keys
                .into_iter()
                .map(|key| {
                    if key == doc_key() {
                        WorkFeedChange::Upserted(doc_entry())
                    } else {
                        WorkFeedChange::Removed(key)
                    }
                })
                .collect())
        })
    }

    fn mark_done(
        &self,
        _viewer: FeedViewer,
        targets: Vec<WorkFeedDoneTarget>,
    ) -> BoxFuture<'_, Result<WorkFeedDoneOutcome, FeedError>> {
        let items = targets
            .iter()
            .map(|target| target.key.clone())
            .collect::<Vec<_>>();
        self.0.dones.lock().unwrap().push(targets);
        Box::pin(async move {
            Ok(WorkFeedDoneOutcome {
                receipt: DoneReceipt {
                    keys: items.iter().map(FeedKey::id).collect(),
                    notification_ids: vec![Uuid::from_u128(1)],
                    ..Default::default()
                },
                items,
            })
        })
    }

    fn undo_done(
        &self,
        _viewer: FeedViewer,
        scope: WorkFeedScope,
        receipt: DoneReceipt,
    ) -> BoxFuture<'_, Result<Vec<WorkFeedChange<SoupProjectionHydration>>, FeedError>> {
        self.0.undos.lock().unwrap().push((scope, receipt));
        Box::pin(async { Ok(vec![WorkFeedChange::Upserted(doc_entry())]) })
    }
}

/// Triggers a test drives by hand.
#[derive(Default, Clone)]
struct ManualTriggers {
    sender: Arc<Mutex<Option<tokio::sync::mpsc::Sender<FeedTrigger>>>>,
    subscribed: Arc<Mutex<Vec<(MacroUserIdStr<'static>, CandidateKeying, bool)>>>,
}

impl FeedTriggers for ManualTriggers {
    fn subscribe(
        &self,
        user: MacroUserIdStr<'static>,
        keying: CandidateKeying,
        own_work: bool,
    ) -> tokio::sync::mpsc::Receiver<FeedTrigger> {
        let (sender, receiver) = tokio::sync::mpsc::channel(8);
        *self.sender.lock().unwrap() = Some(sender);
        self.subscribed
            .lock()
            .unwrap()
            .push((user, keying, own_work));
        receiver
    }
}

struct NoTeam;

impl FeedViewerResolver for NoTeam {
    fn team(
        &self,
        _user: MacroUserIdStr<'static>,
    ) -> BoxFuture<'_, Result<Option<EntityAccessReceipt<MemberTeamRole>>, rootcause::Report>> {
        Box::pin(async { Ok(None) })
    }
}

fn context(
    service: &Arc<RecordingWorkFeedService>,
    triggers: &ManualTriggers,
) -> WorkFeedGraphqlContext {
    WorkFeedGraphqlContext::new(
        Recording(Arc::clone(service)),
        Arc::new(triggers.clone()),
        Arc::new(NoTeam),
    )
}

fn viewer_id() -> MacroUserIdStr<'static> {
    MacroUserIdStr::parse_from_str(VALID_USER_ID).unwrap()
}

#[tokio::test]
async fn work_feed_pages_hydrated_stacked_entries_for_the_viewer() {
    let harness = harness();
    let service = Arc::new(RecordingWorkFeedService::default());
    let triggers = ManualTriggers::default();

    let response = harness
        .schema
        .execute(
            harness
                .request(
                    r#"{ user { workFeed(input: {
                        scope: { mode: ATTENTION, types: [DOCUMENT, TASK, CHANNEL_THREAD] },
                        state: UNSEEN,
                        limit: 10
                    }) {
                        nextCursor
                        nextPosition { sortAt entityId }
                        entries {
                            sortAt touchedAt revision primaryReason primaryStackIndex
                            item {
                                id state attentionAt unseenCount
                                entity { __typename id }
                                stacks {
                                    kind threadId latestAt unseen count
                                    notifications(limit: 1) { id eventType state }
                                }
                            }
                        }
                    } } }"#,
                    authenticated_parts(),
                )
                .data(context(&service, &triggers)),
        )
        .await;
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    let page = &data["user"]["workFeed"];
    let entry = &page["entries"][0];

    assert_eq!(entry["sortAt"], at(9).to_rfc3339());
    assert_eq!(entry["touchedAt"], at(9).to_rfc3339());
    assert_eq!(entry["primaryReason"], "OWN_WORK");
    assert!(entry["primaryStackIndex"].is_null());
    let revision = FeedRevision::decode(entry["revision"].as_str().unwrap()).unwrap();
    assert_eq!(revision.attention_through, Some(at(7)));

    let item = &entry["item"];
    assert_eq!(item["id"], format!("document:{DOC_ID}"));
    assert_eq!(item["state"], "UNSEEN");
    assert_eq!(item["unseenCount"], 2);
    assert_eq!(item["entity"]["__typename"], "GraphqlSoupDocument");
    assert_eq!(item["entity"]["id"], DOC_ID.to_string());
    let stack = &item["stacks"][0];
    assert_eq!(stack["kind"], "COMMENTS");
    assert_eq!(stack["count"], 2);
    assert_eq!(stack["unseen"], true);
    assert_eq!(stack["latestAt"], at(7).to_rfc3339());
    assert_eq!(stack["notifications"].as_array().unwrap().len(), 1);
    assert_eq!(
        stack["notifications"][0]["id"],
        Uuid::from_u128(2).to_string()
    );

    let position = FeedPosition::decode(page["nextCursor"].as_str().unwrap()).unwrap();
    assert_eq!(position.entity_id, DOC_ID.to_string());
    assert_eq!(page["nextPosition"]["entityId"], DOC_ID.to_string());
    assert_eq!(
        page["nextPosition"]["sortAt"],
        position.sort_at.to_rfc3339()
    );

    let pages = service.pages.lock().unwrap();
    let (viewer, query) = &pages[0];
    assert_eq!(viewer.user.as_ref(), VALID_USER_ID);
    assert_eq!(query.scope.mode, WorkFeedMode::Attention);
    assert_eq!(
        query.scope.types,
        vec![
            WorkFeedItemType::Document,
            WorkFeedItemType::Task,
            WorkFeedItemType::ChannelThread
        ]
    );
    assert_eq!(query.state, Some(WorkFeedItemState::Unseen));
    assert_eq!(query.limit, 10);
}

#[tokio::test]
async fn work_feed_rejects_a_bad_cursor_before_reading() {
    let harness = harness();
    let service = Arc::new(RecordingWorkFeedService::default());
    let response = harness
        .schema
        .execute(
            harness
                .request(
                    r#"{ user { workFeed(input: { cursor: "nope" }) { nextCursor } } }"#,
                    authenticated_parts(),
                )
                .data(context(&service, &ManualTriggers::default())),
        )
        .await;
    assert_eq!(response.errors[0].message, "invalid work feed cursor");
    assert!(service.pages.lock().unwrap().is_empty());
}

#[tokio::test]
async fn mark_done_completes_the_observed_revision_and_undo_restores_it() {
    let harness = harness();
    let service = Arc::new(RecordingWorkFeedService::default());
    let triggers = ManualTriggers::default();
    let revision = FeedRevision {
        attention_through: Some(at(7)),
    }
    .encode();

    let done = harness
        .schema
        .execute(
            harness
                .request(
                    &format!(
                        r#"mutation {{ markWorkFeedItemsDone(input: {{ items: [
                            {{ id: "document:{DOC_ID}", revision: "{revision}" }}
                        ] }}) {{ itemIds undoToken }} }}"#
                    ),
                    authenticated_parts(),
                )
                .data(viewer_id())
                .data(context(&service, &triggers)),
        )
        .await;
    assert!(done.errors.is_empty(), "{:?}", done.errors);
    let done = done.data.into_json().unwrap();
    assert_eq!(
        done["markWorkFeedItemsDone"]["itemIds"],
        serde_json::json!([format!("document:{DOC_ID}")])
    );
    let targets = service.dones.lock().unwrap()[0].clone();
    assert_eq!(targets[0].key, doc_key());
    assert_eq!(targets[0].revision.unwrap().attention_through, Some(at(7)));

    let undo_token = done["markWorkFeedItemsDone"]["undoToken"].as_str().unwrap();
    let undo = harness
        .schema
        .execute(
            harness
                .request(
                    &format!(
                        r#"mutation {{ undoWorkFeedItemsDone(input: {{
                            undoToken: "{undo_token}", scope: {{ mode: WORK }}
                        }}) {{ patches {{ __typename
                            ... on WorkFeedEntryUpserted {{ entry {{ item {{ id }} }} }}
                        }} }} }}"#
                    ),
                    authenticated_parts(),
                )
                .data(viewer_id())
                .data(context(&service, &triggers)),
        )
        .await;
    assert!(undo.errors.is_empty(), "{:?}", undo.errors);
    let undo = undo.data.into_json().unwrap();
    assert_eq!(
        undo["undoWorkFeedItemsDone"]["patches"][0]["entry"]["item"]["id"],
        format!("document:{DOC_ID}")
    );
    let undos = service.undos.lock().unwrap();
    assert_eq!(undos[0].1.notification_ids, vec![Uuid::from_u128(1)]);
}

#[tokio::test]
async fn mark_done_requires_an_authenticated_user() {
    let harness = harness();
    let service = Arc::new(RecordingWorkFeedService::default());
    let response = harness
        .schema
        .execute(
            harness
                .request(
                    r#"mutation { markWorkFeedItemsDone(input: { items: [] }) { itemIds } }"#,
                    authenticated_parts(),
                )
                .data(context(&service, &ManualTriggers::default())),
        )
        .await;
    assert_eq!(response.errors[0].message, "authentication required");
    assert!(service.dones.lock().unwrap().is_empty());
}

#[tokio::test]
async fn work_feed_updates_batch_recomputed_patches() {
    let harness = harness();
    let service = Arc::new(RecordingWorkFeedService::default());
    let triggers = ManualTriggers::default();
    let other =
        FeedKey::new(ModelEntityType::Chat.with_entity_string(Uuid::from_u128(0xC4A7).to_string()));

    let request = async_graphql::Request::new(
        r#"subscription { workFeedUpdates(scope: { mode: WORK }) {
            __typename
            ... on WorkFeedEntryUpserted { entry { sortAt item { id state } } }
            ... on WorkFeedEntryRemoved { itemId }
            ... on WorkFeedInvalidated { refresh }
        } }"#,
    )
    .data(viewer_id())
    .data(context(&service, &triggers));
    let responses = harness.schema.execute_stream(request);
    pin_mut!(responses);

    // The subscription opens its triggers lazily, on first poll.
    let first = tokio::spawn({
        let triggers = triggers.clone();
        let other = other.clone();
        async move {
            let sender = loop {
                if let Some(sender) = triggers.sender.lock().unwrap().clone() {
                    break sender;
                }
                tokio::task::yield_now().await;
            };
            // A burst inside one window becomes one recompute.
            sender
                .send(FeedTrigger::Changed(vec![doc_key().into_entity()]))
                .await
                .unwrap();
            sender
                .send(FeedTrigger::Changed(vec![
                    other.into_entity(),
                    doc_key().into_entity(),
                ]))
                .await
                .unwrap();
            sender
        }
    });
    let response = responses.next().await.expect("patch batch");
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    let patches = data["workFeedUpdates"].as_array().unwrap();
    assert_eq!(patches.len(), 2);
    assert_eq!(patches[0]["__typename"], "WorkFeedEntryUpserted");
    assert_eq!(
        patches[0]["entry"]["item"]["id"],
        format!("document:{DOC_ID}")
    );
    assert_eq!(patches[1]["__typename"], "WorkFeedEntryRemoved");
    assert_eq!(patches[1]["itemId"], other.id());
    {
        let recomputes = service.recomputes.lock().unwrap();
        assert_eq!(recomputes.len(), 1);
        assert_eq!(recomputes[0].0.mode, WorkFeedMode::Work);
        assert_eq!(recomputes[0].1, vec![doc_key(), other.clone()]);
    }

    let sender = first.await.unwrap();
    sender.send(FeedTrigger::Invalidated).await.unwrap();
    let response = responses.next().await.expect("invalidation");
    let data = response.data.into_json().unwrap();
    assert_eq!(
        data["workFeedUpdates"][0]["__typename"],
        "WorkFeedInvalidated"
    );

    // When the sources end, the stream ends with an error to resubscribe.
    drop(sender);
    *triggers.sender.lock().unwrap() = None;
    let response = responses.next().await.expect("closing error");
    assert!(!response.errors.is_empty());
    assert_eq!(
        triggers.subscribed.lock().unwrap().as_slice(),
        &[(viewer_id(), CandidateKeying::ThreadScoped, true)]
    );
}