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
import { throwOnErr } from '@core/util/result';
import type { CacheHost } from '@graphql-cache/index';
import { subscribeToVisibleCacheChanges } from '@queries/subscribe-to-visible-cache-changes';
import type { VisibleCalendar } from '@service-calendar/generated/schemas/visibleCalendar';
import { emailClient } from '@service-email/client';
import { CalendarsDocument } from '@service-storage/graphql/generated/graphql';
import { getGraphqlSoupClient } from '@service-storage/graphql-soup';
import {
keepPreviousData,
useQuery,
useQueryClient,
} from '@tanstack/solid-query';
import { type Accessor, createEffect, onCleanup } from 'solid-js';
import { useGraphqlCalendarHost } from './graphql/flag';
import { mapVisibleCalendar } from './graphql/map';
import {
calendarCacheAnswered,
withinCacheHeadStart,
} from './graphql/readiness';
import { calendarKeys } from './keys';
export type { VisibleCalendar };
const CALENDAR_LIST_STALE_TIME = 5 * 60_000;
/**
* Calendars visible to the viewer across connected and delegated inboxes,
* primaries and writable calendars first — the order pickers present them in.
*/
export function useVisibleCalendarsQuery(
options?: Accessor<{ enabled?: boolean }>
) {
const cacheHost = useGraphqlCalendarHost();
const activeQueryClient = useQueryClient();
createEffect(() => {
const host = cacheHost();
if (!host) return;
onCleanup(
subscribeToVisibleCacheChanges(host, () =>
activeQueryClient.invalidateQueries(
{ queryKey: calendarKeys.visibleCalendars._ctx.graphql.queryKey },
{ cancelRefetch: false }
)
)
);
});
return useQuery<
VisibleCalendar[],
Error,
VisibleCalendar[],
| typeof calendarKeys.visibleCalendars.queryKey
| typeof calendarKeys.visibleCalendars._ctx.graphql.queryKey
>(() => {
const host = cacheHost();
const enabled = options?.().enabled !== false;
return host
? cachedVisibleCalendarsQueryOptions(host, enabled)
: visibleCalendarsQueryOptions(enabled);
});
}
// Cached options outlive the hook. The host is the app-level cache service,
// not component state, so the factory may close over it.
function cachedVisibleCalendarsQueryOptions(host: CacheHost, enabled: boolean) {
return {
queryKey: calendarKeys.visibleCalendars._ctx.graphql.queryKey,
queryFn: () => readCalendarList(host),
staleTime: Infinity,
networkMode: 'offlineFirst' as const,
enabled,
placeholderData: keepPreviousData,
reconcile: 'id' as const,
};
}
function visibleCalendarsQueryOptions(enabled: boolean) {
return {
queryKey: calendarKeys.visibleCalendars.queryKey,
queryFn: listCalendars,
staleTime: CALENDAR_LIST_STALE_TIME,
refetchInterval: outlookCalendarRefetchInterval,
enabled,
placeholderData: keepPreviousData,
// Polls return new objects for unchanged calendars. Without reconciling,
// an open calendar picker rebuilds its rows and loses keyboard focus.
reconcile: 'id' as const,
};
}
function outlookCalendarRefetchInterval(query: {
state: { data: VisibleCalendar[] | undefined };
}): number | false {
return query.state.data?.some((calendar) => calendar.provider === 'outlook')
? 30_000
: false;
}
async function listCalendars() {
return (await throwOnErr(() => emailClient.listCalendars())).calendars;
}
/**
* Reads the list from the cache. A cache that has not answered a calendar read
* gets a head start; past it, or if its read fails, the list comes from REST.
*/
async function readCalendarList(host: CacheHost) {
if (calendarCacheAnswered(host)) return readCachedCalendars();
const cached = await withinCacheHeadStart(
(async () => {
try {
return await readCachedCalendars();
} catch {
return 'not-ready' as const;
}
})()
);
return cached === 'not-ready' ? listCalendars() : cached;
}
/** Reads the calendar list from the cache, fetching it once when absent. */
async function readCachedCalendars() {
const result = await getGraphqlSoupClient()
.query(CalendarsDocument, {}, { requestPolicy: 'cache-first' })
.toPromise();
if (result.error) throw result.error;
if (!result.data) throw new Error('Calendars returned no data');
return result.data.user.calendars.map(mapVisibleCalendar);
}