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 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;
}