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.

24.2 KB
Raw Blame
import type { ListDataSource } from '@app/components/list';
import { createPositionHolds } from '@app/features/next-soup/position-holds';
import type { EmailRowReminder } from '@app/features/reminders/core/email-row-reminder';
import {
  buildFlatSoupRows,
  createSearchState,
  createSoupLoadMoreRow,
  createSoupRowStore,
  createTagFacetContext,
  type SoupRow,
  soupSearchMatchType,
  tagFacetReady,
  testFacets,
} from '@app/features/soup';
import { withEntityNotifications } from '@app/features/soup/entity-notifications';
import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
import { useUserId } from '@core/context/user';
import { arrayEquals } from '@core/util/compareUtils';
import { matchesTokenSubsequences } from '@core/util/string';
import {
  type EmailEntity,
  type EntityData,
  isEmailEntity,
  type WithNotification,
} from '@entity';
import {
  createLocalDraftSource,
  localDraftEntities,
} from '@queries/email/local-draft-source';
import { useFavoritesQuery } from '@queries/favorites/favorites';
import { useSoupAstItemsQuery } from '@queries/soup/items';
import { useSearchSoupQuery } from '@queries/soup/search';
import type { TagSetResponse } from '@service-properties/generated/schemas/tagSetResponse';
import { type Accessor, createMemo, createSignal, indexArray } from 'solid-js';
import { match } from 'ts-pattern';
import { canSearchEmailTab, isExcludedEmailFolder } from '../constants';
import { EMAIL_FACETS, type EmailFacetContext } from '../filters/email-facets';
import type { EmailTab, EmailViewState } from '../types';
import { advanceEmptyAliasPages } from './advance-empty-alias-pages';
import { buildEmailQuery, type EmailQueryContext } from './email-query';
import { buildEmailDateRows } from './email-results';
import { buildEmailSearchRequest } from './email-search';
import { emailAdmissionBatches, mergeEmailAdmission } from './read-admission';
import { useFocusEmailSource } from './use-focus-email-source';
import { useReminderEmailSource } from './use-reminder-email-source';
import { useScheduledEmailSource } from './use-scheduled-email-source';

export type EmailDataSourceItem = SoupRow<WithNotification<EntityData>>;

export type EmailDataSource = ListDataSource<EmailDataSourceItem> & {
  reminderForThread?: (threadId: string) => EmailRowReminder | undefined;
  /** Keeps rows in place while an action changes their sort. */
  positions?: { hold: (entityIds: readonly string[]) => void };
};

export type EmailDataSourceInput = Pick<
  EmailViewState,
  'tab' | 'search' | 'inboxIds' | 'facets' | 'focusSort' | 'aliasFilter'
>;

export type UseEmailDataSourceOptions = {
  /**
   * Read by the caller, not here: the source runs under the split panel's
   * owner, above the view's tag-sets provider.
   */
  tagSets: Accessor<readonly TagSetResponse[]>;
  tagSetsReady: Accessor<boolean>;
};

/**
 * The server owns importance, calendar, sent and inbox scoping, so — as with
 * the legacy presets' client filters — only the shapes a cached entity can
 * contradict are re-checked here.
 */
function emailMatchesTab(
  entity: EmailEntity,
  tab: EmailTab,
  userId: string | undefined,
  /** A search hit, which the service matched across archived mail too. */
  searchHit: boolean
): boolean {
  return (
    match(tab)
      .with('drafts', () => entity.isDraft)
      .with('archived', () => entity.done === true)
      .with('shared', () => userId !== undefined && entity.ownerId !== userId)
      // The inbox views list only threads still in the inbox; a cached page can
      // carry a row whose record was archived after the page was fetched.
      // Searching them still finds archived mail, as it always has.
      .with('important', 'noise', () => searchHit || entity.done !== true)
      .with(
        'favorites',
        'sent',
        'scheduled',
        'reminders',
        'calendar',
        'all',
        'focus',
        'spam',
        'trash',
        () => true
      )
      .exhaustive(() => true)
  );
}

// Provider-neutral folder membership needs a server lookup; arbitrary realtime
// entities cannot establish it from labels (Outlook has no Gmail system labels).
const rejectFolderInsert = () => false;
const folderQueryOptions = (tab: EmailTab) =>
  isExcludedEmailFolder(tab)
    ? {
        keepPreviousData: false,
        meta: { normalize: false, insertFilter: rejectFolderInsert },
      }
    : {};

type AdmittedEmails = {
  scope: string;
  items: EmailEntity[];
};

type RetainedEmailPublication = AdmittedEmails & {
  resolved: Map<string, EmailEntity | undefined>;
};

/** Query, service search, and row assembly owned by the Email view. */
export function useEmailDataSource(
  state: EmailDataSourceInput,
  options: UseEmailDataSourceOptions
): EmailDataSource {
  const notificationSource = useGlobalNotificationSource();
  const userId = useUserId();
  const scheduled = useScheduledEmailSource(state);
  const reminders = useReminderEmailSource(state, options);
  const focus = useFocusEmailSource(state, options);
  const showsReminders = () => state.tab === 'reminders';
  const showsFocus = () => state.tab === 'focus';
  const showsScheduled = () => state.tab === 'scheduled';
  const showsFavorites = () => state.tab === 'favorites';
  // Uses GraphQL favorites with enable-graphql-soup, REST otherwise. Guard
  // the data read so a pending favorites request cannot suspend the view.
  const favorites = useFavoritesQuery({ entityType: ['email_thread'] });
  const favoriteThreadIds = createMemo(() =>
    favorites.isSuccess
      ? [
          ...new Set(
            favorites.data?.favorites.map((favorite) => favorite.entityId) ?? []
          ),
        ].sort()
      : undefined
  );
  const favoriteIds = createMemo(() => new Set(favoriteThreadIds()));

  const facetContext = createMemo(
    (): EmailFacetContext => createTagFacetContext(options.tagSets())
  );

  const queryContext = createMemo(
    (): EmailQueryContext => ({
      tab: state.tab,
      inboxIds: state.inboxIds === undefined ? undefined : [...state.inboxIds],
      aliasFilter: state.aliasFilter,
      facets: state.facets,
      facetContext: facetContext(),
    })
  );

  // Discovery must apply read status before pagination, not scan through
  // pages of read mail to find an unread thread.
  const queryArgs = createMemo(() => buildEmailQuery(queryContext()));
  const tagsReady = () => tagFacetReady(state.facets, options.tagSetsReady());
  // Soup owns favorite filtering; only the separate search service needs IDs.
  const searchFavoritesReady = () =>
    !showsFavorites() || favoriteThreadIds() !== undefined;
  const filtersReady = () =>
    tagsReady() && (!state.search.trim() || searchFavoritesReady());
  const sourceEnabled = () =>
    tagsReady() &&
    state.tab !== 'scheduled' &&
    state.tab !== 'reminders' &&
    state.tab !== 'focus';
  const searchContext = (): EmailQueryContext => ({
    ...queryContext(),
    ...(showsFavorites() ? { favoriteThreadIds: favoriteThreadIds() } : {}),
  });
  const query = useSoupAstItemsQuery(queryArgs, () => ({
    enabled: sourceEnabled(),
    // Folder previews must not overwrite the same thread's All Mail preview.
    ...folderQueryOptions(state.tab),
  }));
  const localDrafts = createLocalDraftSource(
    () => query.transport === 'graphql'
  );
  const isListPending = () =>
    !filtersReady() || query.isPending || query.isPlaceholderData;

  const selectEmails = (entities: EntityData[]): EmailEntity[] => {
    const context = queryContext();
    // Rows and their lookups come from search hits while searching.
    const searchHits = search.isSearching();
    const selected: EmailEntity[] = [];
    for (const entity of entities) {
      if (!isEmailEntity(entity)) continue;
      if (!emailMatchesTab(entity, context.tab, userId(), searchHits)) continue;
      if (showsFavorites()) {
        if (entity.isFavorited === false) continue;
        // Search results have no Soup favorite field and use search's ID scope.
        if (search.isSearching() && !favoriteIds().has(entity.id)) continue;
      }

      selected.push(entity);
    }
    return selected;
  };

  // Mail search retains server relevance; recoverable local drafts are merged below.
  const search = createSearchState({
    surface: () => 'email',
    text: () => (canSearchEmailTab(state.tab) ? state.search : ''),
    enabled: () => sourceEnabled() && searchFavoritesReady(),
    disableLocalSearch: () => true,
    buildRequest: (request) =>
      buildEmailSearchRequest(searchContext(), request),
  });

  // Search retains its existing relevance service. Intersect its candidate
  // IDs with the same GraphQL alias predicate used by normal mail discovery;
  // never broaden an alias selection or depend on incomplete search previews.
  const aliasSearchBatches = createMemo(() =>
    state.aliasFilter &&
    search.usesServiceSearch() &&
    search.searchQuery.isSuccess &&
    !search.searchQuery.isPlaceholderData
      ? emailAdmissionBatches(selectEmails(search.data()))
      : []
  );
  const aliasSearchQueries = indexArray(aliasSearchBatches, (ids) =>
    useSoupAstItemsQuery(
      () => buildEmailQuery(queryContext(), ids()),
      () => ({
        enabled: !!state.aliasFilter && search.usesServiceSearch(),
        keepPreviousData: false,
        ...folderQueryOptions(state.tab),
      })
    )
  );
  const aliasSearchPending = () =>
    aliasSearchQueries().some(
      (query) => query.isPending || query.isPlaceholderData || query.isFetching
    );
  const aliasSearchError = () =>
    aliasSearchQueries().find((query) => query.error)?.error;
  const aliasSearchIds = createMemo(
    () =>
      new Set(
        aliasSearchQueries().flatMap((query) =>
          !query.isPending && !query.isPlaceholderData
            ? (query.data?.entities.map((entity) => entity.id) ?? [])
            : []
        )
      )
  );

  const rawEntities = createMemo<EntityData[]>(() => {
    // Scheduled/Reminders/Focus disable native discovery. Reading its pending data
    // would suspend the whole split even though that query is not fetching.
    // Disabled searches can also retain previous-facet placeholder data.
    if (!sourceEnabled() || !filtersReady()) return [];

    if (!search.isSearching()) {
      // Previous-tab/inbox rows are not valid results for the new query.
      // REST placeholders need the same treatment as pending GraphQL reads.
      // Background refreshes still retain usable current-query cache results.
      if (isListPending()) return [];

      return query.data?.entities ?? [];
    }

    // Never admit the previous text/filter query's placeholder results.
    if (!search.usesServiceSearch() || search.searchQuery.isPlaceholderData)
      return [];
    return state.aliasFilter
      ? search.data().filter((entity) => aliasSearchIds().has(entity.id))
      : search.data();
  });

  const hasReadFilter = () => (state.facets.read?.length ?? 0) > 0;
  const scope = createMemo(() =>
    JSON.stringify([
      userId(),
      queryArgs().body,
      state.facets,
      state.search.trim(),
    ])
  );
  const matchesOtherFacets = (email: EmailEntity) =>
    testFacets(
      { ...state.facets, read: [] },
      EMAIL_FACETS,
      email,
      facetContext()
    );

  // Remember identity and position, not permanent membership. Bounded readers
  // below keep admitted rows live without weakening discovery's read filter.
  const admitted = createMemo<AdmittedEmails>(
    (previous) => {
      const currentScope = scope();
      if (!hasReadFilter()) return { scope: currentScope, items: [] };
      const previousItems =
        previous.scope === currentScope ? previous.items : [];
      const known = new Set(previousItems.map((email) => email.id));
      const current = selectEmails(rawEntities()).filter(
        (email) =>
          matchesOtherFacets(email) &&
          (known.has(email.id) ||
            testFacets(
              { read: state.facets.read ?? [] },
              EMAIL_FACETS,
              email,
              facetContext()
            ))
      );
      return {
        scope: currentScope,
        items: mergeEmailAdmission(previousItems, current),
      };
    },
    { scope: '', items: [] }
  );

  const admissionBatches = createMemo(
    () => (filtersReady() ? emailAdmissionBatches(admitted().items) : []),
    [],
    {
      equals: (left, right) =>
        left.length === right.length &&
        left.every((ids, index) => arrayEquals(ids, right[index])),
    }
  );
  const retainedQueries = indexArray(admissionBatches, (ids) => {
    const list = useSoupAstItemsQuery(
      () => buildEmailQuery(queryContext(), ids()),
      () => ({
        enabled:
          filtersReady() && (!search.isSearching() || !!state.aliasFilter),
        ...folderQueryOptions(state.tab),
      })
    );
    const searchQuery = useSearchSoupQuery(
      () =>
        buildEmailSearchRequest(
          searchContext(),
          {
            query: state.search.trim(),
            matchType: soupSearchMatchType(state.search),
          },
          ids()
        ),
      () => ({ enabled: filtersReady() && search.usesServiceSearch() })
    );
    return {
      ids,
      data: () => {
        if (!search.isSearching())
          return !list.isPending && !list.isPlaceholderData
            ? list.data?.entities
            : undefined;
        if (!searchQuery.isSuccess || searchQuery.isPlaceholderData)
          return undefined;
        if (!state.aliasFilter) return searchQuery.data;
        if (list.isPending || list.isPlaceholderData) return undefined;
        const members = list.data?.entities;
        // A failed membership read is unknown, not proof every row disappeared.
        if (!members) return undefined;
        const memberIds = new Set(members.map((entity) => entity.id));
        return searchQuery.data.filter((entity) => memberIds.has(entity.id));
      },
      error: () =>
        search.isSearching()
          ? (searchQuery.error ?? (state.aliasFilter ? list.error : undefined))
          : list.error,
      refresh: async () => {
        if (search.usesServiceSearch()) {
          await Promise.all([
            searchQuery.refetch(),
            ...(state.aliasFilter ? [list.refresh()] : []),
          ]);
        } else if (!search.isSearching()) await list.refresh();
      },
    };
  });

  const publication = createMemo<RetainedEmailPublication>(
    (previous) => {
      const currentScope = scope();
      if (!filtersReady() || (!search.isSearching() && isListPending())) {
        return { scope: currentScope, items: [], resolved: new Map() };
      }
      if (!hasReadFilter()) {
        return {
          scope: currentScope,
          items: selectEmails(rawEntities()).filter(matchesOtherFacets),
          resolved: new Map(),
        };
      }
      // Carry the last confirmed lookup through a new batch's pending read,
      // including explicit non-membership. Otherwise pagination can flash old
      // unread flags or resurrect an archived row from its discovery snapshot.
      const current = new Map(
        previous.scope === currentScope ? previous.resolved : []
      );
      for (const lookup of retainedQueries()) {
        const data = lookup.data();
        if (data === undefined) continue;
        const byId = new Map(
          selectEmails(data).map((email) => [email.id, email])
        );
        for (const id of lookup.ids()) current.set(id, byId.get(id));
      }
      return {
        scope: currentScope,
        resolved: current,
        items: admitted().items.flatMap((snapshot) => {
          // Snapshots bridge the first pending lookup only; subsequent pending
          // reads retain the canonical value or exclusion from that lookup.
          const email = current.has(snapshot.id)
            ? current.get(snapshot.id)
            : snapshot;
          return email &&
            selectEmails([email]).length > 0 &&
            matchesOtherFacets(email)
            ? [email]
            : [];
        }),
      };
    },
    { scope: '', items: [], resolved: new Map() }
  );
  // Working copies can exist before sender metadata allows a GraphQL save.
  // Keep them discoverable without waiting for the remote list/search.
  const recoverable = () =>
    state.tab === 'drafts' || (state.tab === 'all' && !!state.search.trim())
      ? localDraftEntities(localDrafts.drafts()).filter(
          (email) => email.ownerId === userId()
        )
      : [];
  // Resolve recovery threads independently of the active filters. Otherwise an
  // excluded thread could reappear with the synthetic first-use draft flags.
  const recoveryBatches = createMemo(() =>
    emailAdmissionBatches(recoverable())
  );
  const recoveryQueries = indexArray(recoveryBatches, (ids) =>
    useSoupAstItemsQuery(
      () => ({
        ...buildEmailQuery(
          {
            tab: 'all',
            inboxIds: undefined,
            facets: {},
            facetContext: facetContext(),
          },
          ids()
        ),
        transport: 'graphql',
      }),
      () => ({ enabled: sourceEnabled(), keepPreviousData: false })
    )
  );
  const localRows = () => {
    if (!filtersReady()) return [];
    const remote = new Map(
      [
        ...recoveryQueries().flatMap((query) =>
          !query.isPending && !query.isPlaceholderData
            ? (query.data?.entities.filter(isEmailEntity) ?? [])
            : []
        ),
        ...rawEntities().filter(isEmailEntity),
        ...publication().items,
      ].map((email) => [email.id, email])
    );
    return recoverable()
      .map((email) => {
        const confirmed = remote.get(email.id);
        return confirmed
          ? {
              ...confirmed,
              name: email.name,
              snippet: email.snippet,
              updatedAt: email.updatedAt,
            }
          : email;
      })
      .filter(
        (email) =>
          email.ownerId === userId() &&
          (!state.inboxIds?.length ||
            (!!email.linkId && state.inboxIds.includes(email.linkId))) &&
          (!state.aliasFilter ||
            (email.linkId === state.aliasFilter.inboxId &&
              email.senderEmail?.toLowerCase() ===
                state.aliasFilter.emailAddress.toLowerCase())) &&
          testFacets(state.facets, EMAIL_FACETS, email, facetContext()) &&
          matchesTokenSubsequences(email.name, state.search.trim())
      );
  };
  const entities = () => {
    const recovered = localRows();
    const ids = new Set(recovered.map((email) => email.id));
    return [
      ...recovered,
      ...publication().items.filter((email) => !ids.has(email.id)),
    ];
  };

  // Discarding a draft moves a thread back to its last received message;
  // the row stays where it was until the list's scope changes.
  const positions = createPositionHolds({ scope });
  const listEntities = createMemo((): WithNotification<EntityData>[] => {
    const rows = entities().map((email) =>
      withEntityNotifications(email, notificationSource)
    );
    return search.isSearching() ? rows : positions.apply(rows);
  });

  const usesServiceSearch = search.usesServiceSearch;
  const [refreshing, setRefreshing] = createSignal(false);
  const aliasAdvance = advanceEmptyAliasPages({
    scope,
    enabled: () =>
      sourceEnabled() && !!state.aliasFilter && usesServiceSearch(),
    ready: () =>
      filtersReady() &&
      search.searchQuery.isSuccess &&
      !search.isFetching() &&
      !refreshing() &&
      !search.searchQuery.isPlaceholderData &&
      !aliasSearchPending() &&
      !search.error() &&
      !aliasSearchError() &&
      !retainedQueries().some((query) => query.error()),
    hasItems: () => entities().length > 0,
    hasNextPage: search.hasNextPage,
    loadMore: search.fetchNextPage,
  });

  const hasMore = () => {
    if (!filtersReady()) return false;
    if (usesServiceSearch()) return search.hasNextPage();
    return !isListPending() && query.hasNextPage;
  };

  const isLoadingMore = () => {
    if (usesServiceSearch())
      return (
        search.isFetchingNextPage() ||
        aliasSearchPending() ||
        aliasAdvance.isFetching()
      );
    return query.isFetchingNextPage;
  };

  const builtItems = createMemo<EmailDataSourceItem[]>(() => {
    // Search results keep their relevance order, so only the list page is
    // bucketed by date.
    const result: EmailDataSourceItem[] = search.isSearching()
      ? buildFlatSoupRows(listEntities())
      : buildEmailDateRows(listEntities(), new Date(), positions.sortTs);

    if (hasMore()) {
      result.push(
        createSoupLoadMoreRow({
          scopeId: `email:${state.tab}`,
          isLoading: isLoadingMore(),
        })
      );
    }

    return result;
  });
  const items = createSoupRowStore(builtItems);

  const isLoading = () => {
    if (localRows().length > 0) return false;
    if (search.isSearching() && showsFavorites() && favorites.isError)
      return false;
    if (!filtersReady()) return true;
    if (!search.isSearching()) {
      // A query held back for the tag sets is loading, not empty.
      return isListPending();
    }
    if (entities().length > 0) return false;
    if (usesServiceSearch())
      return (
        search.isLoading() || aliasSearchPending() || aliasAdvance.isFetching()
      );
    return query.isLoading;
  };

  return {
    positions: {
      hold: (entityIds) => positions.hold(listEntities(), entityIds),
    },
    reminderForThread: (threadId) =>
      showsReminders() ? reminders.reminderForThread?.(threadId) : undefined,
    items: () =>
      showsReminders()
        ? reminders.items()
        : showsScheduled()
          ? scheduled.items()
          : showsFocus()
            ? focus.items()
            : items(),
    isLoading: () =>
      showsReminders()
        ? reminders.isLoading()
        : showsScheduled()
          ? scheduled.isLoading()
          : showsFocus()
            ? focus.isLoading()
            : isLoading(),
    isFetching: () => {
      if (showsReminders()) return reminders.isFetching();
      if (showsScheduled()) return scheduled.isFetching();
      if (showsFocus()) return focus.isFetching();
      if (search.isSettling()) return true;
      return (
        refreshing() ||
        aliasAdvance.isFetching() ||
        (usesServiceSearch() ? search.isFetching() : query.isFetching)
      );
    },
    error: () => {
      if (showsReminders()) return reminders.error();
      if (showsScheduled()) return scheduled.error();
      if (showsFocus()) return focus.error();
      return (
        (search.isSearching() && showsFavorites()
          ? favorites.error
          : undefined) ??
        (usesServiceSearch() ? search.error() : query.error) ??
        aliasSearchError() ??
        aliasAdvance.error() ??
        retainedQueries()
          .map((lookup) => lookup.error())
          .find((error) => error instanceof Error) ??
        undefined
      );
    },
    hasMore: () =>
      showsReminders()
        ? reminders.hasMore()
        : !showsScheduled() && !showsFocus() && hasMore(),
    isLoadingMore: () =>
      showsReminders()
        ? reminders.isLoadingMore()
        : !showsScheduled() && !showsFocus() && isLoadingMore(),
    loadMore: async () => {
      if (showsReminders()) {
        await reminders.loadMore();
        return;
      }
      if (showsScheduled() || showsFocus()) return;
      if (usesServiceSearch()) {
        aliasAdvance.resetError();
        await search.fetchNextPage();
        return;
      }
      await query.fetchNextPage();
    },
    refresh: async () => {
      if (showsReminders()) {
        await reminders.refresh();
        return;
      }
      if (showsScheduled()) {
        await scheduled.refresh();
        return;
      }
      if (showsFocus()) {
        await focus.refresh();
        return;
      }
      const requestScope = scope();
      setRefreshing(true);
      aliasAdvance.resetError();
      try {
        if (showsFavorites() && search.isSearching()) await favorites.refetch();
        await (usesServiceSearch() ? search.refetch() : query.refresh());
        if (scope() !== requestScope) return;
        // Refresh admission after search publishes its candidates: a refetch
        // can detach/recreate these readers even when their IDs stay the same.
        await Promise.all([
          ...(usesServiceSearch() && state.aliasFilter
            ? aliasSearchQueries().map((lookup) => lookup.refresh())
            : []),
          ...retainedQueries().map((lookup) => lookup.refresh()),
        ]);
      } finally {
        setRefreshing(false);
      }
    },
  } satisfies EmailDataSource;
}