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::sync::{Arc, Mutex};
use calendar_events::domain::{
changes::{CalendarChangeQueryService, CalendarChangesPage, CalendarWatermark},
models::{
CalendarCapabilities, CalendarEvent, CalendarMentionPreview, CalendarMentionRequestItem,
CalendarOccurrence, CalendarOccurrenceCursor, CalendarProvider, CalendarSyncStatus,
EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility,
GuestPolicy, OccurrenceException, OccurrenceListing, OccurrenceRange, TeamOutOfOffice,
ViewerCapabilities, VisibleCalendar,
},
ports::CalendarOccurrenceService,
};
use chrono::TimeZone;
use graphql_calendar::CalendarGraphqlContext;
use rootcause::Report;
use super::*;
const EVENT_ID: Uuid = Uuid::from_u128(0xe1);
const LINK_ID: Uuid = Uuid::from_u128(0x11);
#[derive(Default)]
struct RecordingCalendarReads {
viewers: Mutex<Vec<String>>,
}
fn listing() -> OccurrenceListing {
let starts_at = chrono::Utc.with_ymd_and_hms(2026, 10, 6, 15, 0, 0).unwrap();
let time = EventTime::Timed {
starts_at,
ends_at: starts_at + chrono::Duration::hours(1),
time_zone: None,
};
OccurrenceListing {
event: CalendarEvent {
id: EVENT_ID,
owner_id: VALID_USER_ID.to_owned(),
ical_uid: "[email protected]".to_owned(),
calendar_id: None,
sources: Vec::new(),
title: "Planning".to_owned(),
description: None,
location: None,
status: EventStatus::Confirmed,
visibility: EventVisibility::Default,
transparency: EventTransparency::Opaque,
event_type: EventType::Default,
time: time.clone(),
recurrence_lines: Vec::new(),
organizer_email: None,
organizer_name: None,
creator_email: None,
creator_name: None,
conference_url: None,
conference_provider: None,
sequence: 0,
is_read_only: false,
attendees: Vec::new(),
reminders: EventReminders::default(),
guest_policy: GuestPolicy::default(),
is_snapshot: false,
viewer_can: ViewerCapabilities::NONE,
created_at: starts_at,
updated_at: starts_at,
},
occurrence: CalendarOccurrence {
event_id: EVENT_ID,
occurrence_key: time.occurrence_key(),
recurrence_id: None,
time,
is_cancelled: false,
},
link_id: LINK_ID,
exception: OccurrenceException::default(),
}
}
impl CalendarOccurrenceService for RecordingCalendarReads {
async fn list_occurrences(
&self,
requester_id: &str,
_range: OccurrenceRange,
_cursor: Option<CalendarOccurrenceCursor>,
_limit: u16,
) -> Result<Vec<OccurrenceListing>, Report> {
self.viewers.lock().unwrap().push(requester_id.to_owned());
Ok(vec![listing()])
}
async fn sync_status(&self, _requester_id: &str) -> Result<CalendarSyncStatus, Report> {
Ok(CalendarSyncStatus::Ready)
}
async fn list_visible_calendars(
&self,
requester_id: &str,
) -> Result<Vec<VisibleCalendar>, Report> {
self.viewers.lock().unwrap().push(requester_id.to_owned());
Ok(vec![VisibleCalendar {
id: Uuid::from_u128(0xca),
email_link_id: LINK_ID,
email_address: "[email protected]".to_owned(),
name: "Work".to_owned(),
color: None,
is_primary: true,
is_writable: true,
is_subscription: false,
contributes_to_availability: true,
sync_error: None,
provider: CalendarProvider::Google,
capabilities: CalendarCapabilities::google(),
default_reminders: Vec::new(),
}])
}
async fn mention_previews(
&self,
_requester_id: &str,
_items: Vec<CalendarMentionRequestItem>,
) -> Result<Vec<CalendarMentionPreview>, Report> {
unreachable!("not part of the calendar user fields")
}
async fn list_team_out_of_office(
&self,
_requester_id: &str,
_range: OccurrenceRange,
_limit: u16,
) -> Result<Vec<TeamOutOfOffice>, Report> {
unreachable!("not part of the calendar user fields")
}
async fn primary_time_zone(&self, _requester_id: &str) -> Result<Option<String>, Report> {
unreachable!("not part of the calendar user fields")
}
async fn meeting_copies(
&self,
_requester_id: &str,
_event_id: uuid::Uuid,
) -> Result<Vec<calendar_events::domain::models::MeetingCopy>, Report> {
unreachable!("no GraphQL read lists a meeting's copies")
}
async fn event_ics(
&self,
_requester_id: &str,
_event_id: uuid::Uuid,
) -> Result<Option<calendar_events::domain::ics::CalendarEventIcs>, Report> {
unreachable!("not part of the calendar user fields")
}
}
impl CalendarChangeQueryService for RecordingCalendarReads {
async fn current_watermark(&self, requester_id: &str) -> Result<CalendarWatermark, Report> {
self.viewers.lock().unwrap().push(requester_id.to_owned());
Ok(CalendarWatermark::default())
}
async fn changes_since(
&self,
requester_id: &str,
_since: CalendarWatermark,
) -> Result<CalendarChangesPage, Report> {
self.viewers.lock().unwrap().push(requester_id.to_owned());
Ok(CalendarChangesPage {
reset_required: true,
..CalendarChangesPage::default()
})
}
async fn event_change(
&self,
_requester_id: &str,
_event_id: Uuid,
) -> Result<Option<calendar_events::domain::changes::CalendarEventChange>, Report> {
Ok(None)
}
}
#[tokio::test]
async fn calendar_fields_read_through_request_data_for_the_viewer() {
let harness = harness();
let reads = Arc::new(RecordingCalendarReads::default());
let context = CalendarGraphqlContext::new(Arc::clone(&reads), Arc::clone(&reads));
let id_only = harness
.schema
.execute(
harness
.request("{ user { id } }", authenticated_parts())
.data(context.clone()),
)
.await;
assert!(id_only.errors.is_empty(), "{:?}", id_only.errors);
assert!(reads.viewers.lock().unwrap().is_empty());
let response = harness
.schema
.execute(
harness
.request(
r#"{ user {
id
calendars { id linkId }
calendarOccurrences(input: {
start: "2026-10-05T00:00:00Z", end: "2026-10-12T00:00:00Z"
}) {
nodes { id eventId linkId event { id title } }
hasNextPage syncStatus watermark { linkId seq }
}
calendarChanges(input: { since: [] }) { resetRequired }
} }"#,
authenticated_parts(),
)
.data(context),
)
.await;
assert!(response.errors.is_empty(), "{:?}", response.errors);
let data = response.data.into_json().unwrap();
let user = &data["user"];
assert_eq!(user["calendars"][0]["linkId"], LINK_ID.to_string());
let node = &user["calendarOccurrences"]["nodes"][0];
assert_eq!(node["id"], format!("{EVENT_ID}:2026-10-06T15:00:00+00:00"));
assert_eq!(node["event"]["title"], "Planning");
assert_eq!(user["calendarOccurrences"]["syncStatus"], "READY");
assert_eq!(user["calendarChanges"]["resetRequired"], true);
let viewers = reads.viewers.lock().unwrap();
assert_eq!(viewers.len(), 4);
assert!(viewers.iter().all(|viewer| viewer == VALID_USER_ID));
}
#[tokio::test]
async fn calendar_fields_fail_without_the_calendar_context() {
let harness = harness();
let response = harness
.schema
.execute(harness.request("{ user { id calendars { id } } }", authenticated_parts()))
.await;
assert_eq!(response.errors.len(), 1);
}
#[derive(Default)]
struct RecordingCalendarMutations {
deleted: Mutex<Vec<(String, Uuid)>>,
}
impl calendar_events::domain::ports::CalendarMutationService for RecordingCalendarMutations {
async fn create_event(
&self,
_requester_id: &str,
_email_link_id: Option<Uuid>,
_calendar_id: Option<Uuid>,
_draft: calendar_events::domain::models::CalendarEventDraft,
) -> Result<CalendarEvent, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn list_visible_calendars(
&self,
_requester_id: &str,
) -> Result<Vec<VisibleCalendar>, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn update_event(
&self,
_requester_id: &str,
_event_id: Uuid,
_calendar_id: Option<Uuid>,
_patch: calendar_events::domain::models::CalendarEventPatch,
_scope: calendar_events::domain::ports::CalendarUpdateScope,
) -> Result<CalendarEvent, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn delete_event(
&self,
requester_id: &str,
event_id: Uuid,
_calendar_id: Option<Uuid>,
_scope: calendar_events::domain::ports::CalendarDeletionScope,
) -> Result<(), calendar_events::domain::ports::CalendarMutationError> {
self.deleted
.lock()
.unwrap()
.push((requester_id.to_owned(), event_id));
Ok(())
}
async fn respond_to_event(
&self,
_requester_id: &str,
_event_id: Uuid,
_calendar_id: Option<Uuid>,
_response: calendar_events::domain::models::AttendeeResponseStatus,
_scope: calendar_events::domain::ports::CalendarRsvpScope,
_responding_email: Option<String>,
) -> Result<CalendarEvent, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn invite_guests(
&self,
_requester_id: &str,
_event_id: Uuid,
_calendar_id: Option<Uuid>,
_guests: Vec<calendar_events::domain::models::CalendarAttendeeInput>,
_scope: calendar_events::domain::ports::CalendarUpdateScope,
) -> Result<CalendarEvent, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn copy_shared_event(
&self,
_requester_id: &str,
_event_id: Uuid,
_calendar_id: Option<Uuid>,
) -> Result<CalendarEvent, calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
async fn respond_to_join_request(
&self,
_requester_id: &str,
_request_id: Uuid,
_accept: bool,
) -> Result<
calendar_events::domain::join_requests::CalendarJoinRequest,
calendar_events::domain::ports::CalendarMutationError,
> {
unreachable!("only deletion is exercised")
}
async fn disconnect_calendar(
&self,
_requester_id: &str,
_email_link_id: Uuid,
) -> Result<(), calendar_events::domain::ports::CalendarMutationError> {
unreachable!("only deletion is exercised")
}
}
impl calendar_events::domain::ports::CalendarMacroCallService for RecordingCalendarMutations {
async fn create_event_with_macro_call(
&self,
_requester_id: &str,
_email_link_id: Option<Uuid>,
_calendar_id: Option<Uuid>,
_draft: calendar_events::domain::models::CalendarEventDraft,
) -> Result<CalendarEvent, calendar_events::domain::meeting_links::CreateEventWithMacroCallError>
{
unreachable!("only deletion is exercised")
}
}
#[tokio::test]
async fn calendar_mutations_run_for_the_authenticated_viewer() {
let harness = harness();
let mutations = Arc::new(RecordingCalendarMutations::default());
let reads = Arc::new(RecordingCalendarReads::default());
let context =
graphql_calendar::CalendarGraphqlMutationContext::new(Arc::clone(&mutations), reads);
let response = harness
.schema
.execute(
harness
.request(
&format!(
r#"mutation {{ deleteCalendarEvent(input: {{ eventId: "{EVENT_ID}" }}) {{ deletedEventId }} }}"#
),
authenticated_parts(),
)
.data(MacroUserIdStr::parse_from_str(VALID_USER_ID).unwrap())
.data(context),
)
.await;
assert!(response.errors.is_empty(), "{:?}", response.errors);
assert_eq!(
response.data.into_json().unwrap()["deleteCalendarEvent"]["deletedEventId"],
EVENT_ID.to_string()
);
assert_eq!(
*mutations.deleted.lock().unwrap(),
vec![(VALID_USER_ID.to_owned(), EVENT_ID)]
);
}