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 { LocalDraft } from '@app/features/email-compose/core/local-draft';
import type { EmailEntity } from '@entity/types/entity';
import {
type SoupAstItemsQuery,
useSoupAstItemsQuery,
} from '@queries/soup/items';
import type { useSearchSoupQuery } from '@queries/soup/search';
import { batch, createRoot, createSignal } from 'solid-js';
import { createStore } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { EmailTab, EmailViewState } from '../types';
import { buildEmailQuery } from './email-query';
import {
type EmailDataSource,
type EmailDataSourceItem,
useEmailDataSource,
} from './use-email-query';
const localDrafts = vi.hoisted(() => ({ read: (): LocalDraft[] => [] }));
vi.mock('@queries/email/local-draft-source', async () => ({
...(await import('@queries/email/local-draft-entities')),
createLocalDraftSource: (enabled: () => boolean) => ({
drafts: () => (enabled() ? localDrafts.read() : []),
ready: () => true,
}),
}));
const searchQueryMock = vi.hoisted(() => vi.fn());
const favoritesQueryMock = vi.hoisted(() => vi.fn());
vi.mock('@queries/favorites/favorites', () => ({
useFavoritesQuery: favoritesQueryMock,
}));
const scheduledRows = vi.hoisted(() => ({
current: [] as EmailDataSourceItem[],
}));
vi.mock('@app/features/soup', async () => ({
...(await import('@app/features/soup/filters')),
...(await import('@app/features/soup/collection/rows')),
...(await import('@app/features/soup/collection/row-store')),
...(await import('@app/features/soup/search/create-search-state')),
}));
// Exercise query transitions without loading UI barrels or the local-search provider.
vi.mock('@entity', async () => ({
...(await import('@entity/types/entity')),
...(await import('@entity/utils/notification')),
...(await import('@entity/utils/task-properties')),
...(await import('@entity/utils/company-properties')),
}));
vi.mock('@app/features/soup/search/context', () => ({
useOptionalSearchContext: () => undefined,
}));
vi.mock('@notifications', async () => await import('@notifications/types'));
vi.mock('@queries/soup/search', () => ({
validateSearchServiceText: (text: string) => text.length >= 3,
useSearchSoupQuery: searchQueryMock,
}));
vi.mock('@components/app/GlobalAppState', () => ({
useGlobalNotificationSource: () => ({ notificationsByEntity: () => ({}) }),
}));
vi.mock('@core/context/user', () => ({ useUserId: () => () => 'alice' }));
vi.mock('@queries/soup/items', () => ({ useSoupAstItemsQuery: vi.fn() }));
vi.mock('./use-scheduled-email-source', () => ({
useScheduledEmailSource: () => ({
items: () => scheduledRows.current,
isLoading: () => false,
isFetching: () => false,
error: () => undefined,
hasMore: () => false,
isLoadingMore: () => false,
loadMore: async () => {},
refresh: async () => {},
}),
}));
const focusRows = vi.hoisted(() => ({
current: [] as import('./use-email-query').EmailDataSourceItem[],
}));
vi.mock('./use-focus-email-source', () => ({
useFocusEmailSource: () => ({
items: () => focusRows.current,
isLoading: () => false,
isFetching: () => false,
error: () => undefined,
hasMore: () => false,
isLoadingMore: () => false,
loadMore: async () => {},
refresh: async () => {},
}),
}));
vi.mock('@service-storage/websocket', () => ({
storageWS: { reconnectIfDisconnected: vi.fn() },
createWebSocketJob: vi.fn(),
}));
vi.mock('@service-connection/websocket', () => ({
ws: { addEventListener: vi.fn(), send: vi.fn() },
state: () => 'closed',
createConnectionBlockWebsocketEffect: vi.fn(),
createConnectionWebsocketEffect: vi.fn(),
}));
function email(id: string): EmailEntity {
return {
type: 'email',
id,
name: id,
ownerId: 'alice',
linkId: 'inbox-a',
isRead: false,
isDraft: false,
isImportant: true,
done: false,
updatedAt: new Date('2026-09-21T12:00:00Z'),
};
}
const ids = (source: EmailDataSource) =>
source
.items()
.flatMap((row) => (row.kind === 'entity' ? [row.entity.id] : []));
let dispose: (() => void) | undefined;
function mount(search = '') {
return createRoot((cleanup) => {
dispose = cleanup;
const [state, setState] = createStore<EmailViewState>({
tab: 'noise',
search,
inboxIds: ['inbox-a'],
facets: {},
focusSort: 'importance',
collapsedSidebarSectionIds: [],
});
const [entities, setDiscoveryEntities] = createSignal([email('noise')]);
const [retainedEntities, setRetainedEntities] = createSignal([
email('noise'),
]);
const [retentionLoading, setRetentionLoading] = createSignal(false);
const setEntities = (rows: EmailEntity[]) =>
batch(() => {
setDiscoveryEntities(rows);
setRetainedEntities(rows);
});
const [loading, setLoading] = createSignal(false);
const [paused, setPaused] = createSignal(false);
const [placeholder, setPlaceholder] = createSignal(false);
const [fetching, setFetching] = createSignal(false);
const [tagSetsReady, setTagSetsReady] = createSignal(true);
const [favoriteIds, setFavoriteIds] = createSignal<string[] | undefined>(
[]
);
const [favoritesError, setFavoritesError] = createSignal<Error>();
favoritesQueryMock.mockReturnValue({
get isSuccess() {
return favoriteIds() !== undefined && !favoritesError();
},
get isError() {
return !!favoritesError();
},
get error() {
return favoritesError();
},
get data() {
if (favoriteIds() === undefined)
throw new Error('Read pending favorites');
return { favorites: favoriteIds()!.map((entityId) => ({ entityId })) };
},
refetch: vi.fn(async () => {}),
});
const [searchEntities, setSearchDiscoveryEntities] = createSignal([
email('search'),
]);
const [retainedSearchEntities, setRetainedSearchEntities] = createSignal([
email('search'),
]);
const setSearchEntities = (rows: EmailEntity[]) =>
batch(() => {
setSearchDiscoveryEntities(rows);
setRetainedSearchEntities(rows);
});
const [searchHasMore, setSearchHasMore] = createSignal(true);
const [searchFetching, setSearchFetching] = createSignal(false);
const searchNext = vi.fn(async () => {
setSearchHasMore(false);
});
const searchRefetch = vi.fn(async () => {});
const retainedSearchRefetch = vi.fn(async () => {});
let searchCount = 0;
searchQueryMock.mockImplementation(
(
_args: Parameters<typeof useSearchSoupQuery>[0],
options: Parameters<typeof useSearchSoupQuery>[1]
) => {
const discovery = searchCount++ === 0;
return {
get data() {
if (!discovery && retentionLoading())
throw new Error('Read pending retained search');
return discovery ? searchEntities() : retainedSearchEntities();
},
get isEnabled() {
return options?.().enabled ?? true;
},
get isSuccess() {
return discovery || !retentionLoading();
},
isPlaceholderData: false,
get isFetching() {
return discovery && searchFetching();
},
isFetchingNextPage: false,
get hasNextPage() {
return discovery && searchHasMore();
},
error: null,
fetchNextPage: searchNext,
refetch: discovery ? searchRefetch : retainedSearchRefetch,
};
}
);
const query: SoupAstItemsQuery = {
get data() {
if (loading() || paused()) throw new Error('Read pending query data');
if (state.tab === 'scheduled' || state.tab === 'reminders')
throw new Error('Read disabled native email query');
return { entities: entities(), groups: undefined };
},
get isPending() {
return loading() || paused();
},
get isLoading() {
return loading();
},
get isPlaceholderData() {
return placeholder();
},
get isFetching() {
return fetching();
},
error: null,
hasNextPage: true,
isFetchingNextPage: false,
isFetchNextPageError: false,
isEnabled: true,
transport: 'graphql',
fetchNextPage: vi.fn(async () => {}),
refetch: vi.fn(async () => {}),
refresh: vi.fn(async () => {}),
resetToInitialPage: vi.fn(),
};
const extraLists: {
query: SoupAstItemsQuery;
setError: (error?: Error) => void;
setMissing: (missing: boolean) => void;
}[] = [];
let listCount = 0;
vi.mocked(useSoupAstItemsQuery).mockImplementation(() => {
if (listCount++ === 0) return query;
const [lookupError, setError] = createSignal<Error>();
const [missing, setMissing] = createSignal(false);
const lookup: SoupAstItemsQuery = {
isFetching: false,
get error() {
return lookupError() ?? null;
},
hasNextPage: false,
isFetchingNextPage: false,
isFetchNextPageError: false,
isEnabled: true,
transport: 'graphql',
fetchNextPage: vi.fn(async () => {}),
refetch: vi.fn(async () => {}),
refresh: vi.fn(async () => {}),
resetToInitialPage: vi.fn(),
get data() {
if (retentionLoading()) throw new Error('Read pending retained mail');
return missing()
? undefined
: { entities: retainedEntities(), groups: undefined };
},
get isPending() {
return retentionLoading();
},
get isLoading() {
return retentionLoading();
},
isPlaceholderData: false,
};
extraLists.push({ query: lookup, setError, setMissing });
return lookup;
});
const source = useEmailDataSource(state, {
tagSets: () => [],
tagSetsReady,
});
return {
source,
query,
extraLists,
searchNext,
setSearchHasMore,
setSearchFetching,
setState,
setEntities,
setDiscoveryEntities,
setRetainedEntities,
setRetentionLoading,
setLoading,
setPaused,
setPlaceholder,
setFetching,
setTagSetsReady,
setFavoriteIds,
setFavoritesError,
searchEntities,
setSearchEntities,
setSearchDiscoveryEntities,
setRetainedSearchEntities,
searchRefetch,
retainedSearchRefetch,
};
});
}
describe('Email list query transitions', () => {
const alias = { inboxId: 'inbox-a', emailAddress: '[email protected]' };
it.each(['spam', 'trash'] as const)(
'ignores stale search and isolates %s discovery and retained previews',
(tab) => {
const root = mount('invoice');
root.setState({ tab, facets: { read: ['unread'] } });
root.setEntities([email('folder-result')]);
expect(ids(root.source)).toEqual(['folder-result']);
for (const [args, options] of vi.mocked(useSoupAstItemsQuery).mock
.calls) {
const request = typeof args === 'function' ? args() : args;
const settings = options?.();
expect(request.transport).toBe('rest');
expect(settings?.keepPreviousData).toBe(false);
expect(settings?.meta?.normalize).toBe(false);
expect(settings?.meta?.insertFilter?.({} as never)).toBe(false);
}
for (const [, options] of searchQueryMock.mock.calls) {
expect(options().enabled).toBe(false);
}
}
);
it('refreshes the current alias membership readers after refreshing search, but not inactive readers', async () => {
const root = mount('invoice');
root.setSearchHasMore(false);
root.setRetainedEntities([email('search')]);
root.setState('aliasFilter', alias);
expect(ids(root.source)).toEqual(['search']);
const oldReader = root.extraLists[0].query;
root.searchRefetch.mockImplementation(async () => {
root.setSearchFetching(true);
await Promise.resolve();
root.setSearchFetching(false);
});
await root.source.refresh();
const activeReader = root.extraLists.at(-1)!.query;
expect(activeReader).not.toBe(oldReader);
expect(activeReader.refresh).toHaveBeenCalledOnce();
expect(oldReader.refresh).not.toHaveBeenCalled();
root.setState('aliasFilter', undefined);
await root.source.refresh();
expect(activeReader.refresh).toHaveBeenCalledOnce();
});
it('retains rows and exposes a failed retained alias read until an explicit retry', async () => {
const root = mount('invoice');
root.setSearchHasMore(false);
root.setRetainedEntities([email('search')]);
batch(() => {
root.setState('aliasFilter', alias);
root.setState('facets', { read: ['unread'] });
});
expect(ids(root.source)).toEqual(['search']);
const retained = root.extraLists.at(-1)!;
batch(() => {
retained.setError(new Error('Alias membership unavailable'));
retained.setMissing(true);
});
expect(root.source.error()).toEqual(
new Error('Alias membership unavailable')
);
expect(ids(root.source)).toEqual(['search']);
vi.mocked(retained.query.refresh).mockImplementation(async () => {
retained.setError(undefined);
retained.setMissing(false);
});
await root.source.refresh();
expect(retained.query.refresh).toHaveBeenCalledOnce();
expect(root.retainedSearchRefetch).toHaveBeenCalledOnce();
expect(root.source.error()).toBeUndefined();
});
it('advances sparse alias search pages and waits for membership before fetching again', async () => {
const root = mount('invoice');
root.setRetainedEntities([]);
root.searchNext
.mockImplementationOnce(async () => {
root.setSearchEntities([email('search'), email('still-unmatched')]);
root.setRetainedEntities([]);
root.setRetentionLoading(true);
})
.mockImplementationOnce(async () => {
root.setSearchEntities([
email('search'),
email('still-unmatched'),
email('match'),
]);
root.setRetainedEntities([email('match')]);
root.setSearchHasMore(false);
});
root.setState('aliasFilter', alias);
await vi.waitFor(() => expect(root.searchNext).toHaveBeenCalledOnce());
expect(root.source.isLoading()).toBe(true);
expect(ids(root.source)).toEqual([]);
root.setRetentionLoading(false);
await vi.waitFor(() => expect(ids(root.source)).toEqual(['match']));
expect(root.searchNext).toHaveBeenCalledTimes(2);
expect(root.source.hasMore()).toBe(false);
});
it('stops sparse alias search on exhaustion rather than looping an empty result', async () => {
const root = mount('invoice');
root.setRetainedEntities([]);
root.setState('aliasFilter', alias);
await vi.waitFor(() => expect(root.source.hasMore()).toBe(false));
expect(root.searchNext).toHaveBeenCalledOnce();
expect(ids(root.source)).toEqual([]);
expect(root.source.isLoading()).toBe(false);
});
beforeEach(() => {
localDrafts.read = () => [];
vi.clearAllMocks();
favoritesQueryMock.mockReturnValue({
isSuccess: true,
isError: false,
data: { favorites: [] },
error: null,
refetch: vi.fn(async () => {}),
});
scheduledRows.current = [];
focusRows.current = [];
});
afterEach(() => dispose?.());
it('uses a stable Soup filter and renders without a separate favorites response', () => {
const { source, setState, setEntities, setFavoriteIds, setFavoritesError } =
mount();
setFavoriteIds(undefined);
setState('tab', 'favorites');
setEntities([{ ...email('starred'), isFavorited: true }]);
const args = vi.mocked(useSoupAstItemsQuery).mock.calls[0][0];
const original = JSON.stringify(args());
expect(source.isLoading()).toBe(false);
expect(ids(source)).toEqual(['starred']);
expect(args().body.favorites_only).toBe(true);
expect(args().transport).toBeUndefined();
expect(vi.mocked(useSoupAstItemsQuery).mock.calls[0][1]?.().enabled).toBe(
true
);
setFavoriteIds([]);
expect(JSON.stringify(args())).toBe(original);
expect(ids(source)).toEqual(['starred']);
setFavoritesError(new Error('Favorites unavailable'));
expect(source.error()).toBeUndefined();
expect(ids(source)).toEqual(['starred']);
});
it('removes only the unfavorited row and restores it on rollback without loading', () => {
const { source, setState, setEntities } = mount();
setState('tab', 'favorites');
const first = { ...email('first'), isFavorited: true };
const second = { ...email('second'), isFavorited: true };
setEntities([first, second]);
const args = vi.mocked(useSoupAstItemsQuery).mock.calls[0][0];
const original = JSON.stringify(args());
expect(ids(source)).toEqual(['first', 'second']);
setEntities([{ ...first, isFavorited: false }, second]);
expect(ids(source)).toEqual(['second']);
expect(source.isLoading()).toBe(false);
expect(JSON.stringify(args())).toBe(original);
setEntities([first, second]);
expect(ids(source)).toEqual(['first', 'second']);
expect(source.isLoading()).toBe(false);
});
it('lists the scheduled source on the Scheduled tab instead of soup rows', () => {
scheduledRows.current = [
{
kind: 'entity',
id: 'scheduled-row',
entity: {
...email('scheduled'),
isDraft: true,
scheduledSendTime: '2026-09-27T12:00:00Z',
},
} as EmailDataSourceItem,
];
const { source, setState } = mount();
expect(ids(source)).toEqual(['noise']);
setState('tab', 'scheduled');
expect(ids(source)).toEqual(['scheduled']);
expect(source.hasMore()).toBe(false);
setState('tab', 'noise');
expect(ids(source)).toEqual(['noise']);
});
it('lists the Focus source on the Focus tab and pauses Soup discovery', () => {
focusRows.current = [
{
kind: 'entity',
id: 'focus-row',
entity: {
...email('focus'),
focus: {
category: 'CUSTOMER',
importance: 87,
needsReply: true,
needsFollowUp: false,
importanceTrend: 'FLAT',
},
},
} as EmailDataSourceItem,
];
const { source, setState } = mount();
expect(ids(source)).toEqual(['noise']);
setState('tab', 'focus');
expect(ids(source)).toEqual(['focus']);
expect(source.hasMore()).toBe(false);
const options = vi.mocked(useSoupAstItemsQuery).mock.calls[0][1];
expect(options?.().enabled).toBe(false);
setState('tab', 'noise');
expect(ids(source)).toEqual(['noise']);
});
it('does not read disabled native data on the Reminders tab', () => {
const { source, setState } = mount();
expect(() => setState('tab', 'reminders')).not.toThrow();
expect(ids(source)).toEqual([]);
expect(vi.mocked(useSoupAstItemsQuery).mock.calls[0][1]?.().enabled).toBe(
false
);
setState('tab', 'noise');
expect(ids(source)).toEqual(['noise']);
});
it('drops a done row from Signal and Noise even when the page still lists it', () => {
const { source, setState, setEntities } = mount();
const archived = { ...email('archived'), done: true };
const active = { ...email('active'), done: false };
setEntities([archived, active]);
expect(ids(source)).toEqual(['active']);
setState('tab', 'important');
expect(ids(source)).toEqual(['active']);
});
it('lists done rows on Archived and drops a row when it is unarchived', () => {
const { source, setState, setEntities } = mount();
const archived = { ...email('archived'), done: true };
const active = { ...email('active'), done: false };
batch(() => {
setState('tab', 'archived');
setEntities([archived, active]);
});
expect(ids(source)).toEqual(['archived']);
expect(source.isLoading()).toBe(false);
setEntities([{ ...archived, done: false }, active]);
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(false);
});
it('keeps archived hits when searching Signal and Noise', () => {
const { source, setState, setSearchEntities } = mount('invoice');
const archived = { ...email('archived'), done: true };
const active = { ...email('active'), done: false };
setSearchEntities([archived, active]);
expect(ids(source)).toEqual(['archived', 'active']);
setState('tab', 'important');
expect(ids(source)).toEqual(['archived', 'active']);
});
it('trims archived search results to done threads', () => {
const { source, setState, setSearchEntities } = mount('invoice');
const archived = { ...email('archived'), done: true };
const active = { ...email('active'), done: false };
batch(() => {
setState('tab', 'archived');
setSearchEntities([archived, active]);
});
expect(ids(source)).toEqual(['archived']);
expect(source.isLoading()).toBe(false);
setSearchEntities([{ ...archived, done: false }, active]);
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(false);
});
it('does not suspend on pending native data while its fetch is paused', () => {
const { source, setPaused, setEntities, query } = mount();
expect(() => setPaused(true)).not.toThrow();
expect(query.isLoading).toBe(false);
expect(source.isLoading()).toBe(true);
expect(ids(source)).toEqual([]);
batch(() => {
setEntities([email('resumed')]);
setPaused(false);
});
expect(ids(source)).toEqual(['resumed']);
});
it('does not show Noise rows under other tabs while their cache reads are pending', () => {
const { source, setState, setEntities, setLoading } = mount();
expect(ids(source)).toEqual(['noise']);
for (const tab of ['important', 'sent', 'all'] satisfies EmailTab[]) {
batch(() => {
setState('tab', tab);
setLoading(true);
});
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(true);
expect(source.hasMore()).toBe(false);
expect(source.items()).toEqual([]);
}
batch(() => {
setEntities([email('all')]);
setLoading(false);
});
expect(ids(source)).toEqual(['all']);
expect(source.isLoading()).toBe(false);
expect(source.hasMore()).toBe(true);
});
it('does not keep rows from the previous inbox while the new inbox loads', () => {
const { source, setState, setLoading, setEntities } = mount();
expect(ids(source)).toEqual(['noise']);
batch(() => {
setState('inboxIds', ['inbox-b']);
setLoading(true);
});
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(true);
batch(() => {
setEntities([]);
setLoading(false);
});
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(false);
});
it('treats REST previous-query placeholders as loading, not current results', () => {
const { source, setState, setPlaceholder } = mount();
expect(ids(source)).toEqual(['noise']);
batch(() => {
setState('tab', 'sent');
setPlaceholder(true);
});
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(true);
expect(source.hasMore()).toBe(false);
});
it('filters discovery before pagination while retaining a newly read row across refresh', () => {
const {
source,
setState,
setEntities,
setDiscoveryEntities,
setRetainedEntities,
} = mount();
batch(() => {
setState('facets', { read: ['unread'], done: ['not-done'] });
setEntities([
email('before'),
email('focused'),
{ ...email('already-read'), isRead: true },
email('after'),
]);
});
expect(ids(source)).toEqual(['before', 'focused', 'after']);
const queryArgs = vi.mocked(useSoupAstItemsQuery).mock.calls[0][0];
expect(queryArgs()).toEqual(
buildEmailQuery({
tab: 'noise',
inboxIds: ['inbox-a'],
facets: { read: ['unread'], done: ['not-done'] },
facetContext: { tagPropertyDefinitionByOptionId: new Map() },
})
);
// Both the optimistic response and the subsequent full server page keep
// the newly read row, in place, without admitting previously read mail.
const refreshed = [
email('before'),
{ ...email('focused'), isRead: true },
{ ...email('already-read'), isRead: true },
email('after'),
];
setEntities(refreshed);
expect(ids(source)).toEqual(['before', 'focused', 'after']);
setDiscoveryEntities(refreshed.filter((entity) => !entity.isRead));
expect(ids(source)).toEqual(['before', 'focused', 'after']);
const lookups = vi.mocked(useSoupAstItemsQuery).mock.calls.slice(1);
expect(lookups.length).toBeGreaterThan(0);
expect(JSON.stringify(lookups[0][0]().body.ef)).not.toContain('"Read"');
expect(JSON.stringify(lookups[0][0]().body.ef)).toContain('focused');
// Confirmed archive/trash exclusion drops the row, despite its snapshot.
setRetainedEntities(refreshed.filter((entity) => entity.id !== 'focused'));
expect(ids(source)).toEqual(['before', 'after']);
});
it('discovers unread mail after 100 read threads and paginates only unread discovery', async () => {
const { source, query, setState, setEntities } = mount();
setEntities([]);
setState('facets', { read: ['unread'] });
const mailbox = [
...Array.from({ length: 100 }, (_, index) => ({
...email(`read-${index}`),
isRead: true,
})),
...Array.from({ length: 205 }, (_, index) => email(`unread-${index}`)),
];
const args = vi.mocked(useSoupAstItemsQuery).mock.calls[0][0];
// A server fixture applies the transmitted predicate before its page limit.
const matching = JSON.stringify(args().body.ef).includes('"Read":false')
? mailbox.filter((email) => !email.isRead)
: mailbox;
setEntities(matching.slice(0, 100));
expect(ids(source)).toEqual(
matching.slice(0, 100).map((email) => email.id)
);
expect(ids(source)[0]).toBe('unread-0');
vi.mocked(query.fetchNextPage).mockImplementation(async () => {
setEntities(matching);
});
await source.loadMore();
expect(ids(source)).toHaveLength(205);
expect(query.fetchNextPage).toHaveBeenCalledOnce();
const lookupArgs = vi
.mocked(useSoupAstItemsQuery)
.mock.calls.slice(1)
.map(([args]) => args());
expect(lookupArgs).toHaveLength(3);
expect(lookupArgs.every((args) => args.params.limit === 100)).toBe(true);
expect(
lookupArgs.map(
(args) =>
(JSON.stringify(args.body.ef).match(/"ThreadId"/g) ?? []).length
)
).toEqual([100, 100, 5]);
});
it('retains read search hits through a filtered search refresh using ID-scoped readless lookups', async () => {
const {
source,
setState,
setSearchDiscoveryEntities,
setRetainedSearchEntities,
searchRefetch,
retainedSearchRefetch,
} = mount('invoice');
setState('facets', { read: ['unread'] });
expect(ids(source)).toEqual(['search']);
batch(() => {
setSearchDiscoveryEntities([]);
setRetainedSearchEntities([{ ...email('search'), isRead: true }]);
});
await source.refresh();
expect(ids(source)).toEqual(['search']);
expect(source.items().find((row) => row.kind === 'entity')).toMatchObject({
entity: { isRead: true },
});
expect(searchRefetch).toHaveBeenCalledOnce();
expect(retainedSearchRefetch).toHaveBeenCalledOnce();
const discovery = searchQueryMock.mock.calls[0][0]();
const retained = searchQueryMock.mock.calls.at(-1)![0]();
expect(discovery.body.filters.email_filters.is_read).toBe(false);
expect(retained.body.filters.email_filters).toMatchObject({
email_thread_ids: ['search'],
importance: false,
link_ids: ['inbox-a'],
});
expect(retained.body.filters.email_filters.is_read).toBeUndefined();
expect(retained.body.query).toBe('invoice');
setRetainedSearchEntities([]);
expect(ids(source)).toEqual([]);
});
it('bridges pending retained reads without suspending, then honors authoritative exclusions', () => {
const {
source,
setState,
setDiscoveryEntities,
setRetainedEntities,
setRetentionLoading,
} = mount();
batch(() => {
setState('facets', { read: ['unread'] });
setRetentionLoading(true);
});
expect(ids(source)).toEqual(['noise']);
setDiscoveryEntities([]);
expect(ids(source)).toEqual(['noise']);
batch(() => {
setRetainedEntities([]);
setRetentionLoading(false);
});
expect(ids(source)).toEqual([]);
setRetentionLoading(true);
expect(ids(source)).toEqual([]);
});
it('keeps the confirmed read flag while a retained batch reloads', () => {
const {
source,
setState,
setDiscoveryEntities,
setRetainedEntities,
setRetentionLoading,
} = mount();
setState('facets', { read: ['unread'] });
expect(ids(source)).toEqual(['noise']);
batch(() => {
setDiscoveryEntities([]);
setRetainedEntities([{ ...email('noise'), isRead: true }]);
});
expect(source.items().find((row) => row.kind === 'entity')).toMatchObject({
entity: { isRead: true },
});
setRetentionLoading(true);
expect(source.items().find((row) => row.kind === 'entity')).toMatchObject({
entity: { isRead: true },
});
});
it('does not retain admitted hits when the search text changes', () => {
const {
source,
setState,
setSearchDiscoveryEntities,
setRetainedSearchEntities,
} = mount('invoice');
setState('facets', { read: ['unread'] });
expect(ids(source)).toEqual(['search']);
batch(() => {
setSearchDiscoveryEntities([]);
setRetainedSearchEntities([{ ...email('search'), isRead: true }]);
});
expect(ids(source)).toEqual(['search']);
setState('search', 'different');
expect(ids(source)).toEqual([]);
});
it('resets read admission when the read filter changes', () => {
const { source, setState, setEntities } = mount();
setState('facets', { read: ['unread'] });
expect(ids(source)).toEqual(['noise']);
setEntities([{ ...email('noise'), isRead: true }]);
expect(ids(source)).toEqual(['noise']);
setState('facets', { read: ['read'] });
expect(ids(source)).toEqual(['noise']);
setState('facets', { read: ['unread'] });
expect(ids(source)).toEqual([]);
});
it('keeps current-query cached results visible during a background refresh', () => {
const { source, setFetching } = mount();
setFetching(true);
expect(ids(source)).toEqual(['noise']);
expect(source.isLoading()).toBe(false);
expect(source.isFetching()).toBe(true);
});
it('clears retained active-search rows and reports loading while tag sets are pending', () => {
const {
source,
setState,
setTagSetsReady,
searchEntities,
setSearchEntities,
} = mount('invoice');
expect(ids(source)).toEqual(['search']);
expect(source.isLoading()).toBe(false);
expect(source.hasMore()).toBe(true);
batch(() => {
setState('facets', { tags: ['pending-tag'] });
setTagSetsReady(false);
});
// The shared search still holds the previous service result.
expect(searchEntities().map((entity) => entity.id)).toEqual(['search']);
expect(ids(source)).toEqual([]);
expect(source.items()).toEqual([]);
expect(source.isLoading()).toBe(true);
expect(source.hasMore()).toBe(false);
batch(() => {
setSearchEntities([email('refined-search')]);
setTagSetsReady(true);
});
expect(ids(source)).toEqual(['refined-search']);
expect(source.isLoading()).toBe(false);
});
it('does not retain unfiltered rows while a tag selection waits for tag sets', () => {
const { source, setState, setTagSetsReady } = mount();
expect(ids(source)).toEqual(['noise']);
batch(() => {
setState('facets', { tags: ['pending-tag'] });
setTagSetsReady(false);
});
expect(ids(source)).toEqual([]);
expect(source.isLoading()).toBe(true);
expect(source.hasMore()).toBe(false);
});
});
vi.mock('./use-reminder-email-source', () => ({
useReminderEmailSource: () => ({
items: () => [],
isLoading: () => false,
isFetching: () => false,
error: () => undefined,
hasMore: () => false,
isLoadingMore: () => false,
loadMore: async () => {},
refresh: async () => {},
}),
}));
it('recovers a first-use draft before remote discovery and preserves mailbox/search scope', () => {
const [copies, setCopies] = createSignal<LocalDraft[]>([
{
key: 'local-draft',
draftId: 'local-draft',
threadId: 'local-thread',
accountId: 'alice',
generation: 'generation',
revision: 1,
acknowledgedRevision: 0,
content: { subject: 'Offline receipt' },
attachments: [],
status: 'dirty',
updatedAt: 1,
},
]);
localDrafts.read = copies;
const state = mount();
state.setState({ tab: 'drafts', inboxIds: undefined });
state.setLoading(true);
expect(ids(state.source)).toEqual(['local-thread']);
expect(state.source.isLoading()).toBe(false);
state.setState('inboxIds', ['inbox-a']);
expect(ids(state.source)).toEqual([]);
setCopies([
{ ...copies()[0], inboxId: 'inbox-a', senderEmail: '[email protected]' },
]);
expect(ids(state.source)).toEqual(['local-thread']);
state.setState('aliasFilter', {
inboxId: 'inbox-a',
emailAddress: '[email protected]',
});
expect(ids(state.source)).toEqual([]);
state.setState('aliasFilter', undefined);
state.setState('search', 'receipt');
expect(ids(state.source)).toContain('local-thread');
state.setState('search', 'unrelated');
expect(ids(state.source)).not.toContain('local-thread');
state.setState({ search: '', facets: { read: ['unread'] } });
expect(ids(state.source)).toEqual([]);
state.setState({ facets: {}, tab: 'sent' });
expect(ids(state.source)).toEqual([]);
state.setState('tab', 'drafts');
state.setLoading(false);
state.setEntities([{ ...email('local-thread'), isDraft: true }]);
expect(ids(state.source)).toEqual(['local-thread']);
expect(
state.source.items().find((row) => row.kind === 'entity')?.entity.name
).toBe('Offline receipt');
setCopies([{ ...copies()[0], status: 'synced', acknowledgedRevision: 1 }]);
expect(ids(state.source)).toEqual(['local-thread']);
});
it('keeps confirmed thread flags when a local reply supplies newer draft text', () => {
localDrafts.read = () => [
{
key: 'reply',
draftId: 'reply',
threadId: 'thread',
accountId: 'alice',
inboxId: 'inbox-a',
generation: 'generation',
revision: 1,
acknowledgedRevision: 0,
content: { subject: 'Local reply' },
attachments: [],
status: 'dirty',
updatedAt: 1,
},
];
const state = mount();
state.setState('tab', 'drafts');
state.setEntities([
{
...email('thread'),
isDraft: true,
isRead: false,
done: true,
isImportant: true,
isSignal: false,
},
]);
state.setState('facets', { read: ['unread'], done: ['done'] });
expect(ids(state.source)).toEqual(['thread']);
expect(
state.source.items().find((row) => row.kind === 'entity')?.entity
).toMatchObject({
name: 'Local reply',
isRead: false,
done: true,
isImportant: true,
isSignal: false,
});
});
it('does not resurrect a filtered thread with synthetic local draft flags', () => {
localDrafts.read = () => [
{
key: 'reply',
draftId: 'reply',
threadId: 'thread',
accountId: 'alice',
inboxId: 'inbox-a',
generation: 'generation',
revision: 1,
acknowledgedRevision: 0,
content: { subject: 'Local reply' },
attachments: [],
status: 'dirty',
updatedAt: 1,
},
];
const state = mount();
state.setState({ tab: 'drafts', facets: { done: ['not-done'] } });
state.setDiscoveryEntities([]);
state.setRetainedEntities([
{ ...email('thread'), isDraft: true, done: true },
]);
expect(ids(state.source)).toEqual([]);
state.setState('facets', { done: ['done'] });
expect(ids(state.source)).toEqual(['thread']);
});
it('retains a remote body-search match when its local draft subject does not match', () => {
localDrafts.read = () => [
{
key: 'reply',
draftId: 'reply',
threadId: 'thread',
accountId: 'alice',
inboxId: 'inbox-a',
generation: 'generation',
revision: 1,
acknowledgedRevision: 0,
content: { subject: 'Weekly update' },
attachments: [],
status: 'dirty',
updatedAt: 1,
},
];
const state = mount('invoice');
state.setState('tab', 'all');
state.setSearchEntities([
{
...email('thread'),
name: 'Weekly update',
snippet: 'Your invoice is attached',
},
]);
expect(ids(state.source)).toEqual(['thread']);
expect(
state.source.items().find((row) => row.kind === 'entity')?.entity
).toMatchObject({
snippet: 'Your invoice is attached',
});
});