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.

4.2 KB
Raw Blame
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);
}