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
/**
* @vitest-environment jsdom
*/
import { withDocumentTabItemScope } from '@app/features/next-soup/soup-view/document-tab-scope';
import type { UnifiedNotification } from '@notifications/types';
import type { UnifiedSearchResponseItem } from '@service-search/generated/models';
import type { SoupApiItem } from '@service-storage/generated/schemas';
import type { SoupPage } from '@service-storage/generated/schemas/soupPage';
import type { InfiniteData } from '@tanstack/solid-query';
import { QueryClient, QueryObserver } from '@tanstack/solid-query';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
let testQueryClient: QueryClient;
const getSoupItemsMock = vi.hoisted(() => vi.fn());
const refreshActiveGraphqlSoupQueriesMock = vi.hoisted(() => vi.fn());
const graphqlSoup = vi.hoisted(() => ({ enabled: false }));
vi.mock('@core/constant/featureFlags', async (importOriginal) => {
const actual =
await importOriginal<typeof import('@core/constant/featureFlags')>();
return {
...actual,
isFeatureEnabled: (flag: Parameters<typeof actual.isFeatureEnabled>[0]) =>
flag === actual.enableGraphqlSoup
? graphqlSoup.enabled
: actual.isFeatureEnabled(flag),
};
});
vi.mock('@service-storage/client', () => ({
storageServiceClient: { getSoupItems: getSoupItemsMock },
}));
vi.mock('../graphql/active-queries', () => ({
refreshActiveGraphqlSoupQueries: refreshActiveGraphqlSoupQueriesMock,
}));
vi.mock('../../client', () => ({
get queryClient() {
return testQueryClient;
},
}));
const mockNormalizer = {
setNormalizedData: vi.fn(),
getDependentQueriesByIds: vi.fn<(ids: string[]) => unknown[][]>(() => []),
getObjectById: vi.fn<(id: string) => unknown>(() => null),
};
vi.mock('./normalizer', () => ({
getSoupNormalizer: () => mockNormalizer,
getNormalizationObjectKey: (obj: Record<string, unknown>) => {
if ('tag' in obj && 'data' in obj) {
const data = obj.data as Record<string, unknown>;
if (obj.tag === 'channel') {
const channel = data?.channel as Record<string, unknown> | undefined;
return channel?.id ? `soup:${channel.id}` : undefined;
}
return data?.id ? `soup:${data.id}` : undefined;
}
return undefined;
},
SOUP_NORM_PREFIX: 'soup:',
soupNormKey: (id: string) => `soup:${id}`,
stripSoupNormPrefix: (normKey: string) => normKey.slice('soup:'.length),
}));
import { soupKeys } from '../keys';
import {
// biome-ignore lint/correctness/noPrivateImports: testing private export
buildSingleEntityFilter,
bumpSoupEntityTouchedAt,
getSoupItemId,
insertSoupEntity,
optimisticUpdateSoupEntity,
optimisticUpdateSoupItemUpdatedAt,
refetchSoupEntity,
removeSearchEntities,
removeSoupEntities,
removeSoupEntitiesFromDoneFilteredQueries,
restoreSoupEntityToDoneFilteredQueries,
} from './operations';
// -- Fixtures --
function mockDocumentItem(id: string): SoupApiItem {
return {
tag: 'document',
data: { id, title: 'doc' },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function mockDocumentItemWithUpdatedAt(
id: string,
updatedAt: string
): SoupApiItem {
return {
tag: 'document',
data: { id, title: 'doc', updatedAt },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function mockChannelItem(id: string): SoupApiItem {
return {
tag: 'channel',
data: { channel: { id, name: 'ch' } },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function mockChannelItemWithUpdatedAt(
id: string,
updatedAt: string
): SoupApiItem {
return {
tag: 'channel',
data: { channel: { id, name: 'ch', updated_at: updatedAt } },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function mockChatItem(id: string): SoupApiItem {
return {
tag: 'chat',
data: { id, title: 'chat' },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function mockSoupCache(
pages: SoupApiItem[][]
): InfiniteData<SoupPage, unknown> {
return {
pages: pages.map((items) => ({ items })),
pageParams: pages.map((_, i) => (i === 0 ? null : `cursor-${i}`)),
};
}
function mockSearchResult(type: string, id: string): UnifiedSearchResponseItem {
switch (type) {
case 'document':
return {
type: 'document',
document_id: id,
} as unknown as UnifiedSearchResponseItem;
case 'chat':
return {
type: 'chat',
chat_id: id,
} as unknown as UnifiedSearchResponseItem;
case 'channelMessage': {
const [channelId, messageId] = id.split(':');
return {
type: 'channelMessage',
channel_id: channelId,
message_id: messageId,
} as unknown as UnifiedSearchResponseItem;
}
case 'project':
return { type: 'project', id } as unknown as UnifiedSearchResponseItem;
default:
throw new Error(`Unknown search type: ${type}`);
}
}
function mockSearchCache(
pages: UnifiedSearchResponseItem[][]
): InfiniteData<{ results: UnifiedSearchResponseItem[] }, unknown> {
return {
pages: pages.map((results) => ({ results })),
pageParams: pages.map((_, i) => (i === 0 ? null : `cursor-${i}`)),
};
}
/** Legacy `items` query (flat SoupPage shape) — used by the bulk of the
* pre-existing tests since they assert behavior agnostic of kind. */
const soupSeedKey = [...soupKeys.items._def, 'seed'];
const searchSeedKey = [...soupKeys.search._def, 'seed'];
function seedSoupQuery(data: InfiniteData<SoupPage, unknown>) {
testQueryClient.setQueryData(soupSeedKey, data);
}
function getSoupQuery(): InfiniteData<SoupPage, unknown> | undefined {
return testQueryClient.getQueryData(soupSeedKey);
}
function seedSearchQuery(
data: InfiniteData<{ results: UnifiedSearchResponseItem[] }, unknown>
) {
testQueryClient.setQueryData(searchSeedKey, data);
}
function getSearchQuery() {
return testQueryClient.getQueryData<
InfiniteData<{ results: UnifiedSearchResponseItem[] }, unknown>
>(searchSeedKey);
}
// -- Shared setup --
beforeEach(() => {
vi.clearAllMocks();
graphqlSoup.enabled = false;
getSoupItemsMock.mockResolvedValue({
isErr: () => false,
value: { items: [] },
});
refreshActiveGraphqlSoupQueriesMock.mockResolvedValue(undefined);
testQueryClient = new QueryClient({
defaultOptions: {
queries: { retry: false },
mutations: { retry: false },
},
});
});
afterEach(() => {
testQueryClient.clear();
});
// -- Tests --
describe('getSoupItemId', () => {
it('returns data.id for standard tags', () => {
expect(getSoupItemId(mockDocumentItem('abc-123'))).toBe('abc-123');
});
it('returns data.channel.id for channel tag', () => {
expect(getSoupItemId(mockChannelItem('ch-456'))).toBe('ch-456');
});
});
describe('buildSingleEntityFilter', () => {
const NIL_ID = '00000000-0000-0000-0000-000000000000';
it.each([
{
entityType: 'document' as const,
filterKey: 'document_filters',
idKey: 'document_ids',
},
{
entityType: 'chat' as const,
filterKey: 'chat_filters',
idKey: 'chat_ids',
},
{
entityType: 'channel' as const,
filterKey: 'channel_filters',
idKey: 'channel_ids',
},
{
entityType: 'project' as const,
filterKey: 'project_filters',
idKey: 'project_ids',
},
{
entityType: 'initiative' as const,
filterKey: 'initiative_filters',
idKey: 'initiative_ids',
},
{
entityType: 'call' as const,
filterKey: 'call_filters',
idKey: 'call_ids',
},
])(
'unblocks only $entityType filter with the real entityId',
({ entityType, filterKey, idKey }) => {
const filter = buildSingleEntityFilter(entityType, 'entity-1')!;
expect(filter).not.toBeNull();
expect(filter.limit).toBe(1);
// The target filter uses the real entityId
expect((filter as any)[filterKey][idKey]).toEqual(['entity-1']);
// All other ID-based filters use NIL_ID
const otherFilters = [
'document_filters',
'chat_filters',
'channel_filters',
'channel_thread_filters',
'project_filters',
'call_filters',
].filter((k) => k !== filterKey);
for (const key of otherFilters) {
const ids = Object.values((filter as any)[key])[0];
expect(ids).toEqual([NIL_ID]);
}
}
);
it('project filter defaults include_root to false', () => {
const filter = buildSingleEntityFilter('project', 'entity-1');
expect((filter as any).project_filters.include_root).toBe(false);
});
it('project filter respects includeRoot option', () => {
const filter = buildSingleEntityFilter('project', 'entity-1', {
includeRoot: true,
});
expect((filter as any).project_filters.include_root).toBe(true);
});
});
describe('refetchSoupEntity', () => {
it('refreshes active GraphQL Soup queries when requested', async () => {
await refetchSoupEntity('task-1', 'document', { refreshGraphql: true });
expect(refreshActiveGraphqlSoupQueriesMock).toHaveBeenCalledOnce();
expect(getSoupItemsMock).toHaveBeenCalledOnce();
});
it('does not refresh GraphQL Soup queries for legacy-only refetches', async () => {
await refetchSoupEntity('task-1', 'document');
expect(refreshActiveGraphqlSoupQueriesMock).not.toHaveBeenCalled();
expect(getSoupItemsMock).toHaveBeenCalledOnce();
});
describe('when GraphQL owns the soup lists', () => {
beforeEach(() => {
graphqlSoup.enabled = true;
getSoupItemsMock.mockResolvedValue({
isErr: () => false,
value: { items: [mockDocumentItem('doc-new')] },
});
});
afterEach(() => {
mockNormalizer.getObjectById.mockReturnValue(null);
});
it('neither fetches nor invalidates REST lists for an entity no REST list holds', async () => {
seedSoupQuery(mockSoupCache([[mockDocumentItem('d-1')]]));
await refetchSoupEntity('doc-new', 'document');
expect(getSoupItemsMock).not.toHaveBeenCalled();
expect(testQueryClient.getQueryState(soupSeedKey)?.isInvalidated).toBe(
false
);
expect(getSoupQuery()?.pages[0].items.map(getSoupItemId)).toEqual([
'd-1',
]);
});
it('still refetches an entity a REST list already holds', async () => {
mockNormalizer.getObjectById.mockReturnValue(mockDocumentItem('doc-new'));
await refetchSoupEntity('doc-new', 'document');
expect(getSoupItemsMock).toHaveBeenCalledOnce();
});
it('inserts a just-created entity into REST lists without refetching them', async () => {
seedSoupQuery(mockSoupCache([[mockDocumentItem('d-1')]]));
await refetchSoupEntity('doc-new', 'document', { created: true });
expect(getSoupQuery()?.pages[0].items.map(getSoupItemId)).toEqual([
'doc-new',
'd-1',
]);
expect(testQueryClient.getQueryState(soupSeedKey)?.isInvalidated).toBe(
false
);
});
it('still inserts own-touch creations into REST lists', async () => {
seedSoupQuery(mockSoupCache([[mockDocumentItem('d-1')]]));
await refetchSoupEntity('doc-new', 'document', { ownTouch: true });
expect(getSoupQuery()?.pages[0].items.map(getSoupItemId)).toEqual([
'doc-new',
'd-1',
]);
});
describe('for a new notification', () => {
const notifiedKey = [
...soupKeys.astItems._def,
{ params: { sort_method: 'notified_at' } },
];
const notifiedPages = () =>
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsFlatPage, unknown>
>(notifiedKey);
const notification = {
id: 'notification-1',
entity_id: 'doc-new',
entity_type: 'document',
created_at: '2026-01-02T00:00:00.000Z',
state: 'unseen',
notification_metadata: { tag: 'commented_on_document', content: {} },
} as unknown as UnifiedNotification;
beforeEach(() => {
testQueryClient.setQueryData(notifiedKey, {
pages: [
{
kind: 'flat',
items: [mockDocumentItem('d-1')],
nextCursor: null,
},
],
pageParams: [null],
});
});
const mountNotifiedList = () =>
new QueryObserver(testQueryClient, {
queryKey: notifiedKey,
queryFn: () => notifiedPages() ?? null,
staleTime: Number.POSITIVE_INFINITY,
}).subscribe(() => {});
it('adds a row a mounted notified_at list does not have yet', async () => {
const unmount = mountNotifiedList();
updateSoupForNotification(notification);
await vi.waitFor(() => {
expect(notifiedPages()?.pages[0].items.map(getSoupItemId)).toEqual([
'doc-new',
'd-1',
]);
});
unmount();
});
it('reads a list again when its first read predates the notification', async () => {
const pagesOf = (...ids: string[]) => ({
pages: [
{
kind: 'flat',
items: ids.map((id) => mockDocumentItem(id)),
nextCursor: null,
},
],
pageParams: [null],
});
let settleFirstRead = (_data: unknown) => {};
const queryFn = vi
.fn()
.mockImplementationOnce(
() =>
new Promise((resolve) => {
settleFirstRead = resolve;
})
)
.mockResolvedValue(pagesOf('doc-new', 'd-1'));
testQueryClient.removeQueries({ queryKey: notifiedKey });
const unmount = new QueryObserver(testQueryClient, {
queryKey: notifiedKey,
queryFn,
staleTime: Number.POSITIVE_INFINITY,
}).subscribe(() => {});
updateSoupForNotification(notification);
await vi.waitFor(() => {
expect(getSoupItemsMock).toHaveBeenCalledOnce();
});
await getSoupItemsMock.mock.results[0]?.value;
await new Promise((resolve) => setTimeout(resolve));
settleFirstRead(pagesOf('d-1'));
await vi.waitFor(() => {
expect(notifiedPages()?.pages[0].items.map(getSoupItemId)).toEqual([
'doc-new',
'd-1',
]);
});
unmount();
});
it('reads each list again as soon as its own first read settles', async () => {
const never = () => new Promise(() => {});
const slowKey = [
...soupKeys.astItems._def,
{ params: { sort_method: 'notified_at' }, body: { slow: true } },
];
let settleFirstRead = (_data: unknown) => {};
const queryFn = vi
.fn()
.mockImplementationOnce(
() =>
new Promise((resolve) => {
settleFirstRead = resolve;
})
)
.mockResolvedValue({
pages: [
{
kind: 'flat',
items: [mockDocumentItem('doc-new')],
nextCursor: null,
},
],
pageParams: [null],
});
testQueryClient.removeQueries({ queryKey: notifiedKey });
const unmountFast = new QueryObserver(testQueryClient, {
queryKey: notifiedKey,
queryFn,
staleTime: Number.POSITIVE_INFINITY,
}).subscribe(() => {});
const unmountSlow = new QueryObserver(testQueryClient, {
queryKey: slowKey,
queryFn: never,
staleTime: Number.POSITIVE_INFINITY,
}).subscribe(() => {});
updateSoupForNotification(notification);
await vi.waitFor(() => {
expect(getSoupItemsMock).toHaveBeenCalledOnce();
});
await getSoupItemsMock.mock.results[0]?.value;
await new Promise((resolve) => setTimeout(resolve));
settleFirstRead({
pages: [
{
kind: 'flat',
items: [mockDocumentItem('d-1')],
nextCursor: null,
},
],
pageParams: [null],
});
await vi.waitFor(() => {
expect(queryFn).toHaveBeenCalledTimes(2);
});
unmountFast();
unmountSlow();
});
it('fetches nothing when no notified_at list is mounted', async () => {
await refetchSoupEntity('doc-new', 'document', { notified: true });
expect(getSoupItemsMock).not.toHaveBeenCalled();
});
it('fetches nothing for a change that is not a notification', async () => {
const unmount = mountNotifiedList();
await refetchSoupEntity('doc-new', 'document');
expect(getSoupItemsMock).not.toHaveBeenCalled();
unmount();
});
});
});
});
describe('insertSoupEntity', () => {
it('prepends item to first page only', () => {
const page0 = [mockDocumentItem('d-1')];
const page1 = [mockDocumentItem('d-2')];
seedSoupQuery(mockSoupCache([page0, page1]));
const newItem = mockChatItem('c-1');
insertSoupEntity(newItem);
const cached = getSoupQuery()!;
expect(cached.pages[0].items).toHaveLength(2);
expect(getSoupItemId(cached.pages[0].items[0])).toBe('c-1');
expect(getSoupItemId(cached.pages[0].items[1])).toBe('d-1');
expect(cached.pages[1].items).toHaveLength(1);
expect(getSoupItemId(cached.pages[1].items[0])).toBe('d-2');
});
it('rollback restores original state', () => {
const original = mockSoupCache([[mockDocumentItem('d-1')]]);
seedSoupQuery(original);
const tx = insertSoupEntity(mockChatItem('c-1'));
expect(getSoupQuery()!.pages[0].items).toHaveLength(2);
tx.rollback();
const restored = getSoupQuery()!;
expect(restored.pages[0].items).toHaveLength(1);
expect(getSoupItemId(restored.pages[0].items[0])).toBe('d-1');
});
});
describe('removeSoupEntities', () => {
it('filters matching IDs from all pages', () => {
seedSoupQuery(
mockSoupCache([
[mockDocumentItem('d-1'), mockChatItem('c-1')],
[mockDocumentItem('d-2'), mockChannelItem('ch-1')],
])
);
removeSoupEntities(new Set(['d-1', 'ch-1']));
const cached = getSoupQuery()!;
expect(cached.pages[0].items).toHaveLength(1);
expect(getSoupItemId(cached.pages[0].items[0])).toBe('c-1');
expect(cached.pages[1].items).toHaveLength(1);
expect(getSoupItemId(cached.pages[1].items[0])).toBe('d-2');
});
it('keeps another entity type with the same ID when removal is scoped', () => {
seedSoupQuery(
mockSoupCache([[mockDocumentItem('shared'), mockChannelItem('shared')]])
);
const transaction = removeSoupEntities(
new Set(['shared']),
(item) => item.tag === 'document'
);
expect(getSoupQuery()!.pages[0].items.map((item) => item.tag)).toEqual([
'channel',
]);
transaction.rollback();
expect(getSoupQuery()!.pages[0].items.map((item) => item.tag)).toEqual([
'document',
'channel',
]);
});
it('rollback restores removed items', () => {
seedSoupQuery(
mockSoupCache([[mockDocumentItem('d-1'), mockChatItem('c-1')]])
);
const tx = removeSoupEntities(new Set(['d-1']));
expect(getSoupQuery()!.pages[0].items).toHaveLength(1);
tx.rollback();
const restored = getSoupQuery()!;
expect(restored.pages[0].items).toHaveLength(2);
expect(getSoupItemId(restored.pages[0].items[0])).toBe('d-1');
});
});
describe('removeSoupEntitiesFromDoneFilteredQueries', () => {
const emailItem = (id: string): SoupApiItem =>
({
tag: 'emailThread',
data: { id, inboxVisible: true },
frecency_score: 1,
}) as unknown as SoupApiItem;
// Query keys carry the compiled filter body; done-excluding views embed
// `emailView: 'inbox'` or a compiled `*Done: false` literal.
const inboxViewKey = [...soupKeys.items._def, { emailView: 'inbox' }];
const doneFilterKey = [
...soupKeys.items._def,
{
ef: [
{
'|': [
{ l: { NotificationState: 'unseen' } },
{ l: { NotificationState: 'seen' } },
],
},
],
},
];
const ndFilterKey = [
...soupKeys.items._def,
{ df: [{ '|': [{ l: { ns: 'unseen' } }, { l: { ns: 'seen' } }] }] },
];
const allViewKey = [...soupKeys.items._def, { emailView: 'all' }];
const itemsAt = (key: unknown[]) =>
testQueryClient
.getQueryData<InfiniteData<SoupPage, unknown>>(key)!
.pages[0].items.map(getSoupItemId);
it('does not treat negated or mixed-OR state filters as active-only', () => {
const active = { l: { ns: 'unseen' } };
const cases = [
{ '!': active },
{ '|': [active, { l: { ns: 'done' } }] },
{ '|': [active, { l: { id: 'e-1' } }] },
{ l: { ns: 'done' } },
];
for (const ast of cases) {
const key = [...soupKeys.items._def, { df: ast }];
testQueryClient.setQueryData(key, mockSoupCache([[emailItem('e-1')]]));
removeSoupEntitiesFromDoneFilteredQueries(new Set(['e-1']));
expect(itemsAt(key)).toEqual(['e-1']);
}
});
it('removes from done-filtered queries and keeps done-inclusive ones', () => {
const data = () => mockSoupCache([[emailItem('e-1'), mockChatItem('c-1')]]);
testQueryClient.setQueryData(inboxViewKey, data());
testQueryClient.setQueryData(doneFilterKey, data());
testQueryClient.setQueryData(ndFilterKey, data());
testQueryClient.setQueryData(allViewKey, data());
removeSoupEntitiesFromDoneFilteredQueries(new Set(['e-1']));
expect(itemsAt(inboxViewKey)).toEqual(['c-1']);
expect(itemsAt(doneFilterKey)).toEqual(['c-1']);
expect(itemsAt(ndFilterKey)).toEqual(['c-1']);
expect(itemsAt(allViewKey)).toEqual(['e-1', 'c-1']);
});
it('rollback restores removed rows', () => {
testQueryClient.setQueryData(
inboxViewKey,
mockSoupCache([[emailItem('e-1'), mockChatItem('c-1')]])
);
const tx = removeSoupEntitiesFromDoneFilteredQueries(new Set(['e-1']));
expect(itemsAt(inboxViewKey)).toEqual(['c-1']);
tx.rollback();
expect(itemsAt(inboxViewKey)).toEqual(['e-1', 'c-1']);
});
});
describe('removeSearchEntities', () => {
it('handles agent-session results without treating them as legacy chats', () => {
const session = {
type: 'agentSession',
id: 'session-1',
name: 'Search verification',
owner_id: 'macro|[email protected]',
bot_id: 'bot-1',
created_at: '2026-09-11T00:00:00Z',
updated_at: '2026-09-11T00:00:00Z',
agent_session_search_results: [],
} satisfies UnifiedSearchResponseItem;
seedSearchQuery(
mockSearchCache([[session, mockSearchResult('chat', 'chat-1')]])
);
const tx = removeSearchEntities(new Set(['session-1']));
expect(getSearchQuery()!.pages[0].results).toEqual([
mockSearchResult('chat', 'chat-1'),
]);
tx.rollback();
expect(getSearchQuery()!.pages[0].results[0]).toEqual(session);
});
it('keeps a result of a type this build does not know', () => {
const fromNewerServer = JSON.parse('{"type":"newKind","id":"new-1"}');
seedSearchQuery(
mockSearchCache([
[fromNewerServer, mockSearchResult('document', 'doc-1')],
])
);
removeSearchEntities(new Set(['doc-1']));
expect(getSearchQuery()!.pages[0].results).toEqual([fromNewerServer]);
});
it('filters matching IDs from search results', () => {
seedSearchQuery(
mockSearchCache([
[
mockSearchResult('document', 'doc-1'),
mockSearchResult('chat', 'chat-1'),
],
[mockSearchResult('channelMessage', 'ch-1:msg-1')],
])
);
removeSearchEntities(new Set(['doc-1', 'ch-1:msg-1']));
const cached = getSearchQuery()!;
expect(cached.pages[0].results).toHaveLength(1);
expect(cached.pages[0].results[0].type).toBe('chat');
expect(cached.pages[1].results).toHaveLength(0);
});
it('keeps search results of other types with the same ID', () => {
seedSearchQuery(
mockSearchCache([
[
mockSearchResult('document', 'shared'),
mockSearchResult('chat', 'shared'),
],
])
);
const transaction = removeSearchEntities(
new Set(['shared']),
(item) => item.type === 'document'
);
expect(getSearchQuery()!.pages[0].results.map((item) => item.type)).toEqual(
['chat']
);
transaction.rollback();
expect(getSearchQuery()!.pages[0].results.map((item) => item.type)).toEqual(
['document', 'chat']
);
});
it('rollback restores removed search results', () => {
seedSearchQuery(
mockSearchCache([
[
mockSearchResult('document', 'doc-1'),
mockSearchResult('chat', 'chat-1'),
],
])
);
const tx = removeSearchEntities(new Set(['doc-1']));
expect(getSearchQuery()!.pages[0].results).toHaveLength(1);
tx.rollback();
const restored = getSearchQuery()!;
expect(restored.pages[0].results).toHaveLength(2);
});
});
describe('optimisticUpdateSoupEntity', () => {
it('rollback restores dependent query data', () => {
const dependentKey = [...soupKeys.astItems._def, 'dependent'];
const originalData = mockSoupCache([[mockDocumentItem('d-1')]]);
testQueryClient.setQueryData(dependentKey, originalData);
mockNormalizer.getDependentQueriesByIds.mockReturnValueOnce([dependentKey]);
const tx = optimisticUpdateSoupEntity(mockDocumentItem('d-1'));
tx.rollback();
const restored =
testQueryClient.getQueryData<InfiniteData<SoupPage, unknown>>(
dependentKey
);
expect(restored).toEqual(originalData);
});
});
describe('bumpSoupEntityTouchedAt', () => {
it('stamps a fresh touch on standard entities', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(mockDocumentItem('doc-1'));
bumpSoupEntityTouchedAt('doc-1');
expect(mockNormalizer.setNormalizedData).toHaveBeenCalledWith({
tag: 'document',
data: { id: 'doc-1' },
frecency_score: 1,
touched_at: expect.any(String),
});
});
it('keys channels by their inner channel id', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(mockChannelItem('ch-1'));
bumpSoupEntityTouchedAt('ch-1');
expect(mockNormalizer.setNormalizedData).toHaveBeenCalledWith({
tag: 'channel',
data: { channel: { id: 'ch-1' } },
frecency_score: 1,
touched_at: expect.any(String),
});
});
it('is a no-op for entities not in the cache', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(null);
expect(bumpSoupEntityTouchedAt('missing')).toBeUndefined();
expect(mockNormalizer.setNormalizedData).not.toHaveBeenCalled();
});
});
describe('optimisticUpdateSoupItemUpdatedAt', () => {
it('updates updatedAt for non-channel entities', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(mockDocumentItem('doc-1'));
optimisticUpdateSoupItemUpdatedAt(
'doc-1',
'document',
'2024-01-01T00:00:00.000Z'
);
expect(mockNormalizer.setNormalizedData).toHaveBeenCalledWith({
tag: 'document',
data: { id: 'doc-1', updatedAt: '2024-01-01T00:00:00.000Z' },
frecency_score: 1,
});
});
it('updates updated_at for channel entities', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(mockChannelItem('ch-1'));
optimisticUpdateSoupItemUpdatedAt(
'ch-1',
'channel',
'2024-01-01T00:00:00.000Z'
);
expect(mockNormalizer.setNormalizedData).toHaveBeenCalledWith({
tag: 'channel',
data: {
channel: { id: 'ch-1', updated_at: '2024-01-01T00:00:00.000Z' },
},
frecency_score: 1,
});
});
it('does not update when incoming updatedAt is older or equal (non-channel)', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(
mockDocumentItemWithUpdatedAt('doc-1', '2024-01-02T00:00:00.000Z')
);
optimisticUpdateSoupItemUpdatedAt(
'doc-1',
'document',
'2024-01-01T00:00:00.000Z'
);
mockNormalizer.getObjectById.mockReturnValueOnce(
mockDocumentItemWithUpdatedAt('doc-1', '2024-01-02T00:00:00.000Z')
);
optimisticUpdateSoupItemUpdatedAt(
'doc-1',
'document',
'2024-01-02T00:00:00.000Z'
);
expect(mockNormalizer.setNormalizedData).not.toHaveBeenCalled();
});
it('does not update when incoming updated_at is older (channel)', () => {
mockNormalizer.getObjectById.mockReturnValueOnce(
mockChannelItemWithUpdatedAt('ch-1', '2024-01-02T00:00:00.000Z')
);
optimisticUpdateSoupItemUpdatedAt(
'ch-1',
'channel',
'2024-01-01T00:00:00.000Z'
);
expect(mockNormalizer.setNormalizedData).not.toHaveBeenCalled();
});
it('does nothing when cache entity is missing or tag mismatches', () => {
optimisticUpdateSoupItemUpdatedAt(
'doc-1',
'document',
'2024-01-01T00:00:00.000Z'
);
mockNormalizer.getObjectById.mockReturnValueOnce(mockDocumentItem('doc-1'));
optimisticUpdateSoupItemUpdatedAt(
'doc-1',
'chat',
'2024-01-01T00:00:00.000Z'
);
expect(mockNormalizer.setNormalizedData).not.toHaveBeenCalled();
});
});
// -- Normalized grouped cache tests --
import { soupItemMatchesHomeTab } from '@app/features/home/queries/home-item-filter';
import type { Query } from '@app/features/next-soup/filters/filter-store/types';
import {
soupItemMatchesProjectMembership,
soupItemMatchesQuery,
} from '@app/features/next-soup/filters/query-filters';
import { updateSoupForNotification } from '../../notification/notification-soup';
import type { GroupByField, GroupMeta } from '../grouped/types';
import { NOT_SET_GROUP_KEY } from '../grouped/types';
import type { SoupAstItemsFlatPage, SoupAstItemsGroupedPage } from '../items';
const STATUS_DEF = 'status-def-id';
const STATUS_GROUP_BY: GroupByField = {
type: 'property',
propertyDefinitionId: STATUS_DEF,
};
/** Build a task-like document item with a status property value. */
function mockTaskItem(id: string, statusOption: string): SoupApiItem {
return {
tag: 'document',
data: {
id,
title: `task ${id}`,
properties: [
{
definition: { id: STATUS_DEF },
value: { type: 'SelectOption', value: [statusOption] },
},
],
},
frecency_score: 1,
} as unknown as SoupApiItem;
}
/** Build an email-thread item. Emails carry no task properties, so under a
* property grouping they resolve to the NOT_SET bucket. */
function mockEmailItem(id: string): SoupApiItem {
return {
tag: 'emailThread',
data: { id, subject: `email ${id}` },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function buildGroup(
key: string,
itemIds: string[],
totalCount?: number,
displayOrder?: number
): GroupMeta {
return {
key,
label: key,
displayOrder: displayOrder ?? null,
totalCount: totalCount ?? itemIds.length,
itemIds,
nextCursor: null,
};
}
function mockGroupedParentCache(
items: SoupApiItem[],
groups: GroupMeta[]
): InfiniteData<SoupAstItemsGroupedPage, unknown> {
const itemsById: Record<string, SoupApiItem> = {};
for (const it of items) itemsById[getSoupItemId(it)] = it;
return {
pages: [
{
kind: 'grouped',
items: itemsById,
groups,
nextCursor: null,
},
],
pageParams: [null],
};
}
/** Seed a grouped astItems query with status property grouping metadata. */
function seedGroupedAstQuery(
data: InfiniteData<SoupAstItemsGroupedPage, unknown>,
suffix = 'grouped-seed'
) {
const key = [...soupKeys.astItems._def, {}, {}, STATUS_GROUP_BY, suffix];
testQueryClient.setQueryDefaults(key, { meta: { groupBy: STATUS_GROUP_BY } });
testQueryClient.setQueryData(key, data);
return key;
}
/** Seed a grouped astItems query that also carries an item filter, mirroring
* a list view's `soupItemMatchesListView` gate. */
function seedGroupedAstQueryWithFilter(
data: InfiniteData<SoupAstItemsGroupedPage, unknown>,
itemFilter: (item: SoupApiItem) => boolean,
suffix = 'grouped-filtered-seed'
) {
const key = [...soupKeys.astItems._def, {}, {}, STATUS_GROUP_BY, suffix];
testQueryClient.setQueryDefaults(key, {
meta: { groupBy: STATUS_GROUP_BY, itemFilter },
});
testQueryClient.setQueryData(key, data);
return key;
}
describe('insertSoupEntity — grouped cache', () => {
it('adds item to items pool and prepends id to target group itemIds', () => {
const items = [
mockTaskItem('a-1', 'in_progress'),
mockTaskItem('b-1', 'done'),
];
const groups = [
buildGroup('in_progress', ['a-1'], 3, 0),
buildGroup('done', ['b-1'], 2, 1),
];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
insertSoupEntity(mockTaskItem('a-new', 'in_progress'));
const cached =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
const page = cached.pages[0];
// Pool gained the new item.
expect(page.items['a-new']).toBeDefined();
// in_progress gained the id at the top; totalCount bumped.
const inProgress = page.groups.find((g) => g.key === 'in_progress')!;
expect(inProgress.itemIds).toEqual(['a-new', 'a-1']);
expect(inProgress.totalCount).toBe(4);
// done untouched.
const done = page.groups.find((g) => g.key === 'done')!;
expect(done.itemIds).toEqual(['b-1']);
expect(done.totalCount).toBe(2);
});
it('rollback restores grouped cache', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
const tx = insertSoupEntity(mockTaskItem('a-new', 'in_progress'));
tx.rollback();
const restored =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
expect(restored.pages[0].items['a-new']).toBeUndefined();
expect(restored.pages[0].groups[0].itemIds).toEqual(['a-1']);
expect(restored.pages[0].groups[0].totalCount).toBe(1);
});
});
describe('removeSoupEntities — grouped cache', () => {
it('drops from pool, filters itemIds, decrements totalCount per affected group', () => {
const items = [
mockTaskItem('a-1', 'in_progress'),
mockTaskItem('a-2', 'in_progress'),
mockTaskItem('b-1', 'done'),
];
const groups = [
buildGroup('in_progress', ['a-1', 'a-2'], 5, 0),
buildGroup('done', ['b-1'], 3, 1),
];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
removeSoupEntities(new Set(['a-1']));
const cached =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
const page = cached.pages[0];
expect(page.items['a-1']).toBeUndefined();
expect(page.items['a-2']).toBeDefined();
const inProgress = page.groups.find((g) => g.key === 'in_progress')!;
expect(inProgress.itemIds).toEqual(['a-2']);
expect(inProgress.totalCount).toBe(4);
// done untouched.
const done = page.groups.find((g) => g.key === 'done')!;
expect(done.itemIds).toEqual(['b-1']);
expect(done.totalCount).toBe(3);
});
it('keeps grouped membership when the matching ID has another type', () => {
const key = seedGroupedAstQuery(
mockGroupedParentCache(
[mockTaskItem('shared', 'in_progress')],
[buildGroup('in_progress', ['shared'], 1, 0)]
)
);
removeSoupEntities(new Set(['shared']), (item) => item.tag === 'chat');
const cached =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
expect(cached.pages[0].groups[0].itemIds).toEqual(['shared']);
expect(cached.pages[0].groups[0].totalCount).toBe(1);
expect(cached.pages[0].items.shared).toBeDefined();
});
it('rollback restores grouped cache', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
const tx = removeSoupEntities(new Set(['a-1']));
tx.rollback();
const restored =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
expect(restored.pages[0].items['a-1']).toBeDefined();
expect(restored.pages[0].groups[0].itemIds).toEqual(['a-1']);
expect(restored.pages[0].groups[0].totalCount).toBe(1);
});
});
describe('optimisticUpdateSoupEntity — cross-group move', () => {
it.each([
['2026-11-01T00:00:00Z', 'later'],
[null, 'missing'],
])(
'moves a loaded date property to %s before refetch',
(value, destination) => {
const initial = mockTaskItem('date-item', 'unused');
if (initial.tag !== 'document')
throw new Error('Expected document fixture');
const property = initial.data.properties?.[0];
if (!property) throw new Error('Expected property fixture');
const item: SoupApiItem = {
...initial,
data: {
...initial.data,
properties: [
{
...property,
value: { type: 'Date', value: '2026-10-31T23:59:59Z' },
},
],
},
};
const groupBy: GroupByField = {
type: 'property',
propertyDefinitionId: STATUS_DEF,
bucketing: {
type: 'date_ranges',
ranges: [
{ key: 'soon', start: null, end: '2026-11-01T00:00:00Z' },
{ key: 'later', start: '2026-11-01T00:00:00Z', end: null },
],
missingValueBucketKey: 'missing',
},
};
const key = [...soupKeys.astItems._def, {}, {}, groupBy];
const data = mockGroupedParentCache(
[item],
[
buildGroup('soon', ['date-item'], 8),
buildGroup('later', [], 5),
buildGroup('missing', [], 2),
]
);
testQueryClient.setQueryDefaults(key, { meta: { groupBy } });
testQueryClient.setQueryData(key, data);
const updated: SoupApiItem = {
...item,
data: {
...item.data,
properties: [
{
...property,
value: value === null ? null : { type: 'Date', value },
},
],
},
};
mockNormalizer.getObjectById.mockReturnValue(updated);
testQueryClient.setQueryData(key, {
...data,
pages: [{ ...data.pages[0], items: { 'date-item': updated } }],
});
optimisticUpdateSoupEntity(updated);
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.groups.find((group) => group.key === 'soon')).toMatchObject({
itemIds: [],
totalCount: 7,
});
expect(
page.groups.find((group) => group.key === destination)
).toMatchObject({
itemIds: ['date-item'],
totalCount: destination === 'later' ? 6 : 3,
});
}
);
it('moves item id between groups via itemIds mutations only', () => {
const items = [
mockTaskItem('a-1', 'in_progress'),
mockTaskItem('a-2', 'in_progress'),
mockTaskItem('b-1', 'done'),
];
const groups = [
buildGroup('in_progress', ['a-1', 'a-2'], 5, 0),
buildGroup('done', ['b-1'], 3, 1),
];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
// Simulate what normy would do during the merge: the canonical entity
// (status now `done`) is what reconcile reads from normy's store.
const merged = mockTaskItem('a-1', 'done');
mockNormalizer.getObjectById.mockReturnValue(merged);
// The cache itself also reflects the merge — apply via setQueryData so
// TanStack Query sees the new reference rather than mutating in place.
const cached =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
testQueryClient.setQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key, {
...cached,
pages: cached.pages.map((p, i) =>
i === 0 ? { ...p, items: { ...p.items, 'a-1': merged } } : p
),
});
optimisticUpdateSoupEntity({
tag: 'document',
data: { id: 'a-1' },
frecency_score: 1,
} as unknown as Parameters<typeof optimisticUpdateSoupEntity>[0]);
const after =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
const page = after.pages[0];
expect(page.items['a-1']).toBeDefined();
const inProgress = page.groups.find((g) => g.key === 'in_progress')!;
const done = page.groups.find((g) => g.key === 'done')!;
expect(inProgress.itemIds).toEqual(['a-2']);
expect(inProgress.totalCount).toBe(4);
expect(done.itemIds).toEqual(['a-1', 'b-1']);
expect(done.totalCount).toBe(4);
});
it('no-op when grouping membership did not change', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
mockNormalizer.getObjectById.mockReturnValue(
mockTaskItem('a-1', 'in_progress')
);
optimisticUpdateSoupEntity({
tag: 'document',
data: { id: 'a-1' },
frecency_score: 1,
} as unknown as Parameters<typeof optimisticUpdateSoupEntity>[0]);
const after =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
expect(after.pages[0].groups[0].itemIds).toEqual(['a-1']);
expect(after.pages[0].groups[0].totalCount).toBe(1);
});
it('refreshes item data when membership is unchanged', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQuery(mockGroupedParentCache(items, groups));
// Same group, new data (e.g. a tag/property edit that doesn't move it).
const merged = mockTaskItem('a-1', 'in_progress');
(merged as unknown as { data: { title: string } }).data.title =
'task a-1 (edited)';
mockNormalizer.getObjectById.mockReturnValue(merged);
optimisticUpdateSoupEntity({
tag: 'document',
data: { id: 'a-1' },
frecency_score: 1,
} as unknown as Parameters<typeof optimisticUpdateSoupEntity>[0]);
const after =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!;
const page = after.pages[0];
expect(
(page.items['a-1'] as unknown as { data: { title: string } }).data.title
).toBe('task a-1 (edited)');
expect(page.groups[0].itemIds).toEqual(['a-1']);
expect(page.groups[0].totalCount).toBe(1);
});
});
describe('optimisticUpdateSoupEntity — parent item filter gate', () => {
it('does not bucket an entity that fails the query item filter', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQueryWithFilter(
mockGroupedParentCache(items, groups),
(item) => item.tag !== 'emailThread'
);
mockNormalizer.getObjectById.mockReturnValue(mockEmailItem('e-1'));
optimisticUpdateSoupEntity({
tag: 'emailThread',
data: { id: 'e-1' },
frecency_score: 1,
} as unknown as Parameters<typeof optimisticUpdateSoupEntity>[0]);
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['e-1']).toBeUndefined();
expect(page.groups.map((g) => g.key)).toEqual(['in_progress']);
expect(page.groups.some((g) => g.itemIds.includes('e-1'))).toBe(false);
});
it('removes a previously-bucketed entity that now fails the filter', () => {
const items = [mockTaskItem('a-1', 'in_progress'), mockEmailItem('e-1')];
const groups = [
buildGroup('in_progress', ['a-1'], 1, 0),
buildGroup(NOT_SET_GROUP_KEY, ['e-1'], 1, 1),
];
const key = seedGroupedAstQueryWithFilter(
mockGroupedParentCache(items, groups),
(item) => item.tag !== 'emailThread'
);
mockNormalizer.getObjectById.mockReturnValue(mockEmailItem('e-1'));
optimisticUpdateSoupEntity({
tag: 'emailThread',
data: { id: 'e-1' },
frecency_score: 1,
} as unknown as Parameters<typeof optimisticUpdateSoupEntity>[0]);
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['e-1']).toBeUndefined();
const notSet = page.groups.find((g) => g.key === NOT_SET_GROUP_KEY)!;
expect(notSet.itemIds).toEqual([]);
expect(notSet.totalCount).toBe(0);
});
});
/**
* End-to-end gate for the dynamic-UI `list` widget (macro-2587): the widget
* drives a flat astItems query from a raw `Query` and now attaches
* `soupItemMatchesQuery` as its `itemFilter`. Without it, any optimistic insert
* (e.g. creating a task) prepended into an email-scoped list's cache.
*/
describe('insertSoupEntity — dynamic-ui list query gate', () => {
function seedFlatAstQueryWithFilter(
items: SoupApiItem[],
query: Query,
suffix = 'widget-seed'
) {
const key = [...soupKeys.astItems._def, {}, {}, undefined, suffix];
const data: InfiniteData<SoupAstItemsFlatPage, unknown> = {
pages: [{ kind: 'flat', items, nextCursor: null }],
pageParams: [null],
};
testQueryClient.setQueryDefaults(key, {
meta: {
itemFilter: (item: SoupApiItem) => soupItemMatchesQuery(item, query),
},
});
testQueryClient.setQueryData(key, data);
return key;
}
const emailScopedQuery: Query = { include: { threadId: ['e-1'] } };
it('rejects a newly created task from an email-scoped list', () => {
const key = seedFlatAstQueryWithFilter(
[mockEmailItem('e-1')],
emailScopedQuery
);
insertSoupEntity(mockTaskItem('task-new', 'in_progress'));
const page =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(
key
)!.pages[0];
expect(page.items.map(getSoupItemId)).toEqual(['e-1']);
});
it('still inserts a matching email optimistically', () => {
const key = seedFlatAstQueryWithFilter([mockEmailItem('e-1')], {
include: { threadId: ['e-1', 'e-2'] },
});
insertSoupEntity(mockEmailItem('e-2'));
const page =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(
key
)!.pages[0];
expect(page.items.map(getSoupItemId)).toEqual(['e-2', 'e-1']);
});
});
/**
* End-to-end gate for the folder (project) block (macro-2290): the block drives
* a project-scoped soup view and attaches `soupItemMatchesProjectMembership` as
* its `itemFilter`. Without it, creating or opening an entity outside the folder
* (which refetches the item and prepends it into every matching list cache)
* flashed into the folder's contents until the server refetch corrected it.
*/
describe('insertSoupEntity — folder membership gate', () => {
const FOLDER = 'proj-1';
function folderDocItem(id: string, projectId: string | null): SoupApiItem {
return {
tag: 'document',
data: { id, title: `doc ${id}`, projectId },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function seedFolderScopedQuery(items: SoupApiItem[], suffix = 'folder-seed') {
const key = [...soupKeys.astItems._def, {}, {}, undefined, suffix];
const data: InfiniteData<SoupAstItemsFlatPage, unknown> = {
pages: [{ kind: 'flat', items, nextCursor: null }],
pageParams: [null],
};
testQueryClient.setQueryDefaults(key, {
meta: {
itemFilter: (item: SoupApiItem) =>
soupItemMatchesProjectMembership(item, FOLDER),
},
});
testQueryClient.setQueryData(key, data);
return key;
}
it('rejects a task created outside the folder', () => {
const key = seedFolderScopedQuery([folderDocItem('d-in', FOLDER)]);
insertSoupEntity(folderDocItem('d-root', null));
const page =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(
key
)!.pages[0];
expect(page.items.map(getSoupItemId)).toEqual(['d-in']);
});
it('still inserts an entity that belongs to the folder', () => {
const key = seedFolderScopedQuery([folderDocItem('d-in', FOLDER)]);
insertSoupEntity(folderDocItem('d-new', FOLDER));
const page =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(
key
)!.pages[0];
expect(page.items.map(getSoupItemId)).toEqual(['d-new', 'd-in']);
});
});
/** Shared's request scope must also gate immediate cache admission, even when
* restored/mutable client predicates no longer contain `shared-entity`. */
describe('insertSoupEntity — Shared Files ownership gate', () => {
const ME = 'macro|[email protected]';
const OTHER = 'macro|[email protected]';
const FOLDER = 'folder-1';
const GROUP = 'in_progress';
function document(
id: string,
ownerId: string,
projectId = FOLDER
): SoupApiItem {
const item = mockTaskItem(id, GROUP);
if (item.tag !== 'document') throw new Error('expected document fixture');
return { ...item, data: { ...item.data, ownerId, projectId } };
}
function seed(viewer: string | undefined) {
const existing = document('existing', OTHER);
const filter = withDocumentTabItemScope('shared', viewer, (item) =>
soupItemMatchesProjectMembership(item, FOLDER)
);
const legacy = [...soupKeys.items._def, 'shared-admission'];
const flat = [
...soupKeys.astItems._def,
{},
{},
undefined,
'shared-admission',
];
const grouped = [
...soupKeys.astItems._def,
{},
{},
STATUS_GROUP_BY,
'shared-admission',
];
const expanded = [...soupKeys.groupedGroup._def, 'shared-admission'];
for (const key of [legacy, flat, grouped, expanded])
testQueryClient.setQueryDefaults(key, {
meta: { itemFilter: filter, groupBy: STATUS_GROUP_BY, groupKey: GROUP },
});
testQueryClient.setQueryData(legacy, mockSoupCache([[existing]]));
testQueryClient.setQueryData(flat, {
pages: [{ kind: 'flat', items: [existing], nextCursor: null }],
pageParams: [null],
});
testQueryClient.setQueryData(
grouped,
mockGroupedParentCache([existing], [buildGroup(GROUP, ['existing'])])
);
testQueryClient.setQueryData(expanded, {
pages: [{ items: { existing }, group: buildGroup(GROUP, ['existing']) }],
pageParams: [null],
});
return { legacy, flat, grouped, expanded };
}
function expectIds(keys: ReturnType<typeof seed>, ids: string[]) {
expect(
testQueryClient
.getQueryData<InfiniteData<SoupPage>>(keys.legacy)!
.pages[0].items.map(getSoupItemId)
).toEqual(ids);
expect(
testQueryClient
.getQueryData<InfiniteData<SoupAstItemsFlatPage>>(keys.flat)!
.pages[0].items.map(getSoupItemId)
).toEqual(ids);
const grouped = testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage>
>(keys.grouped)!.pages[0];
expect(grouped.groups[0].itemIds).toEqual(ids);
expect(Object.keys(grouped.items).sort()).toEqual([...ids].sort());
const expanded = testQueryClient.getQueryData<
InfiniteData<{ items: Record<string, SoupApiItem>; group: GroupMeta }>
>(keys.expanded)!.pages[0];
expect(expanded.group.itemIds).toEqual(ids);
expect(Object.keys(expanded.items).sort()).toEqual([...ids].sort());
}
it('rejects owned documents in flat, grouped-parent and expanded-group caches', () => {
const keys = seed(ME);
insertSoupEntity(document('owned-new', ME));
expectIds(keys, ['existing']);
});
it('rejects document admission before viewer identity is known', () => {
const keys = seed(undefined);
insertSoupEntity(document('unverified-new', OTHER));
expectIds(keys, ['existing']);
});
it('retains the project gate and allows eligible shared documents with rollback', () => {
const keys = seed(ME);
insertSoupEntity(document('outside-folder', OTHER, 'other-folder'));
expectIds(keys, ['existing']);
const tx = insertSoupEntity(document('shared-new', OTHER));
expectIds(keys, ['shared-new', 'existing']);
tx.rollback();
expectIds(keys, ['existing']);
});
});
/**
* Regression coverage for macro-3258: a channel row marked done is removed
* from the done-filtered inbox pages, but the entity stays in the normalized
* cache (the sidebar still references it), so an incoming notification took
* the field-merge path and the inbox showed nothing until a refetch.
*/
describe('restoreSoupEntityToDoneFilteredQueries', () => {
const doneFilteredAstKey = (suffix: string) => [
...soupKeys.astItems._def,
{
chanf: [
{
'|': [
{ l: { NotificationState: 'unseen' } },
{ l: { NotificationState: 'seen' } },
],
},
],
},
suffix,
];
const doneFilteredItemsKey = [
...soupKeys.items._def,
{
ef: [
{
'|': [
{ l: { NotificationState: 'unseen' } },
{ l: { NotificationState: 'seen' } },
],
},
],
},
'legacy-inbox',
];
const allViewAstKey = [
...soupKeys.astItems._def,
{ emailView: 'all' },
'all-view',
];
function seedFlatAstQuery(key: unknown[], pages: SoupApiItem[][]) {
const data: InfiniteData<SoupAstItemsFlatPage, unknown> = {
pages: pages.map((items) => ({ kind: 'flat', items, nextCursor: null })),
pageParams: pages.map((_, i) => (i === 0 ? null : `cursor-${i}`)),
};
testQueryClient.setQueryData(key, data);
}
function flatAstItemsAt(key: unknown[], page = 0) {
return testQueryClient
.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(key)!
.pages[page].items.map(getSoupItemId);
}
function cacheChannel(id: string) {
const item = mockChannelItem(id);
mockNormalizer.getObjectById.mockImplementation((normKey) =>
normKey === `soup:${id}` ? item : null
);
return item;
}
it('restores only queries whose state constraint accepts the arriving notification', () => {
cacheChannel('ch-1');
const unseen = [
...soupKeys.astItems._def,
{ chanf: { l: { NotificationState: 'unseen' } } },
];
const seen = [
...soupKeys.astItems._def,
{ chanf: { l: { NotificationState: 'seen' } } },
];
seedFlatAstQuery(unseen, [[]]);
seedFlatAstQuery(seen, [[]]);
seedFlatAstQuery(doneFilteredAstKey('union'), [[]]);
restoreSoupEntityToDoneFilteredQueries('ch-1', 'unseen');
expect(flatAstItemsAt(unseen)).toEqual(['ch-1']);
expect(flatAstItemsAt(seen)).toEqual([]);
expect(flatAstItemsAt(doneFilteredAstKey('union'))).toEqual(['ch-1']);
});
it('combines inbox scoping with sibling AST and DTO state constraints', () => {
cacheChannel('ch-1');
const seenOnly = [
[
...soupKeys.astItems._def,
{ emailView: 'inbox', chanf: { l: { NotificationState: 'seen' } } },
],
[
...soupKeys.astItems._def,
{ emailView: 'inbox', notification_filters: { states: ['seen'] } },
],
[
...soupKeys.astItems._def,
{
emailView: 'inbox',
notification_filters: { states: ['unseen', 'seen'] },
chanf: { l: { NotificationState: 'seen' } },
},
],
];
const active = [
...soupKeys.astItems._def,
{
emailView: 'inbox',
chanf: {
'|': [
{ l: { NotificationState: 'unseen' } },
{ l: { NotificationState: 'seen' } },
],
},
},
];
for (const key of [...seenOnly, active]) seedFlatAstQuery(key, [[]]);
restoreSoupEntityToDoneFilteredQueries('ch-1', 'unseen');
for (const key of seenOnly) expect(flatAstItemsAt(key)).toEqual([]);
expect(flatAstItemsAt(active)).toEqual(['ch-1']);
restoreSoupEntityToDoneFilteredQueries('ch-1', 'seen');
for (const key of seenOnly) expect(flatAstItemsAt(key)).toEqual(['ch-1']);
});
it('prepends the cached entity to done-filtered queries missing it', () => {
cacheChannel('ch-1');
seedFlatAstQuery(doneFilteredAstKey('inbox'), [[mockChatItem('c-1')]]);
testQueryClient.setQueryData(
doneFilteredItemsKey,
mockSoupCache([[mockChatItem('c-1')]])
);
seedFlatAstQuery(allViewAstKey, [[mockChatItem('c-1')]]);
restoreSoupEntityToDoneFilteredQueries('ch-1');
expect(flatAstItemsAt(doneFilteredAstKey('inbox'))).toEqual([
'ch-1',
'c-1',
]);
expect(
testQueryClient
.getQueryData<InfiniteData<SoupPage, unknown>>(doneFilteredItemsKey)!
.pages[0].items.map(getSoupItemId)
).toEqual(['ch-1', 'c-1']);
// Done-inclusive views are left alone.
expect(flatAstItemsAt(allViewAstKey)).toEqual(['c-1']);
});
it('skips queries that already contain the entity on any page', () => {
cacheChannel('ch-1');
seedFlatAstQuery(doneFilteredAstKey('inbox'), [
[mockChatItem('c-1')],
[mockChannelItem('ch-1')],
]);
restoreSoupEntityToDoneFilteredQueries('ch-1');
expect(flatAstItemsAt(doneFilteredAstKey('inbox'), 0)).toEqual(['c-1']);
expect(flatAstItemsAt(doneFilteredAstKey('inbox'), 1)).toEqual(['ch-1']);
});
it('no-ops when the entity is not in the normalized cache', () => {
mockNormalizer.getObjectById.mockReturnValue(null);
seedFlatAstQuery(doneFilteredAstKey('inbox'), [[mockChatItem('c-1')]]);
restoreSoupEntityToDoneFilteredQueries('ch-1');
expect(flatAstItemsAt(doneFilteredAstKey('inbox'))).toEqual(['c-1']);
});
it("respects the query's item filter", () => {
const item = cacheChannel('ch-1');
const key = doneFilteredAstKey('filtered');
testQueryClient.setQueryDefaults(key, {
meta: { itemFilter: (candidate: SoupApiItem) => candidate !== item },
});
seedFlatAstQuery(key, [[mockChatItem('c-1')]]);
restoreSoupEntityToDoneFilteredQueries('ch-1');
expect(flatAstItemsAt(key)).toEqual(['c-1']);
});
it('inserts into a resolvable group of a done-filtered grouped parent', () => {
const task = mockTaskItem('t-new', 'in_progress');
mockNormalizer.getObjectById.mockImplementation((normKey) =>
normKey === 'soup:t-new' ? task : null
);
const key = [
...soupKeys.astItems._def,
{ df: [{ '|': [{ l: { ns: 'unseen' } }, { l: { ns: 'seen' } }] }] },
STATUS_GROUP_BY,
'grouped-inbox',
];
testQueryClient.setQueryDefaults(key, {
meta: { groupBy: STATUS_GROUP_BY },
});
testQueryClient.setQueryData(
key,
mockGroupedParentCache(
[mockTaskItem('t-1', 'in_progress')],
[buildGroup('in_progress', ['t-1'], 1, 0)]
)
);
restoreSoupEntityToDoneFilteredQueries('t-new');
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['t-new']).toBeDefined();
expect(page.groups[0].itemIds).toEqual(['t-new', 't-1']);
});
it('restores the entity into done-filtered expanded group queries', () => {
const task = mockTaskItem('t-new', 'in_progress');
mockNormalizer.getObjectById.mockImplementation((normKey) =>
normKey === 'soup:t-new' ? task : null
);
const makeGroupQueryKey = (bodyMarker: object, suffix: string) => [
...soupKeys.groupedGroup._def,
'in_progress',
STATUS_GROUP_BY,
bodyMarker,
suffix,
];
const doneFilteredKey = makeGroupQueryKey(
{ df: [{ '|': [{ l: { ns: 'unseen' } }, { l: { ns: 'seen' } }] }] },
'done-filtered'
);
const allViewKey = makeGroupQueryKey({ emailView: 'all' }, 'all-view');
const groupData = () => ({
pages: [
{
items: { 't-1': mockTaskItem('t-1', 'in_progress') },
group: buildGroup('in_progress', ['t-1'], 1, 0),
},
],
pageParams: [null],
});
for (const key of [doneFilteredKey, allViewKey]) {
testQueryClient.setQueryDefaults(key, {
meta: { groupBy: STATUS_GROUP_BY, groupKey: 'in_progress' },
});
testQueryClient.setQueryData(key, groupData());
}
restoreSoupEntityToDoneFilteredQueries('t-new');
type GroupPage = { items: Record<string, SoupApiItem>; group: GroupMeta };
const restored =
testQueryClient.getQueryData<InfiniteData<GroupPage, unknown>>(
doneFilteredKey
)!.pages[0];
expect(restored.items['t-new']).toBeDefined();
expect(restored.group.itemIds).toEqual(['t-new', 't-1']);
// Done-inclusive expanded groups are left alone.
const untouched =
testQueryClient.getQueryData<InfiniteData<GroupPage, unknown>>(
allViewKey
)!.pages[0];
expect(untouched.group.itemIds).toEqual(['t-1']);
});
it('invalidates a grouped parent whose group cannot be resolved locally', () => {
cacheChannel('ch-1');
// No groupBy meta mirrors groupings the client cannot bucket (e.g. date):
// insertGroupedPage cannot resolve a target group, so the query refetches.
const key = [
...soupKeys.astItems._def,
{
chanf: [
{
'|': [
{ l: { NotificationState: 'unseen' } },
{ l: { NotificationState: 'seen' } },
],
},
],
},
'grouped-date-inbox',
];
testQueryClient.setQueryData(
key,
mockGroupedParentCache(
[mockChatItem('c-1')],
[buildGroup('today', ['c-1'], 1, 0)]
)
);
restoreSoupEntityToDoneFilteredQueries('ch-1');
expect(testQueryClient.getQueryState(key)?.isInvalidated).toBe(true);
// The page itself is untouched until the refetch lands.
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['ch-1']).toBeUndefined();
});
});
/**
* Regression coverage for macro-3272: the composable inbox's Signal and Noise
* queries both carry `emailView: 'inbox'`, so a websocket notification for a
* cached noise email restored the row into the Signal feed (and vice versa)
* until an unrelated refetch corrected it. The inbox now attaches
* `soupItemMatchesHomeTab` as each tab query's `insertFilter`.
*/
describe('inbox tab gate (Signal vs Noise)', () => {
function inboxEmailItem(id: string, isSignal: boolean): SoupApiItem {
return {
tag: 'emailThread',
data: { id, isSignal },
frecency_score: 1,
} as unknown as SoupApiItem;
}
function seedInboxTabQuery(tab: 'signal' | 'noise', items: SoupApiItem[]) {
const key = [
...soupKeys.astItems._def,
{ emailView: 'inbox' },
`inbox-${tab}`,
];
testQueryClient.setQueryDefaults(key, {
meta: {
insertFilter: (item: SoupApiItem) => soupItemMatchesHomeTab(item, tab),
},
});
const data: InfiniteData<SoupAstItemsFlatPage, unknown> = {
pages: [{ kind: 'flat', items, nextCursor: null }],
pageParams: [null],
};
testQueryClient.setQueryData(key, data);
return key;
}
function cacheEmail(item: SoupApiItem) {
mockNormalizer.getObjectById.mockImplementation((normKey) =>
normKey === `soup:${getSoupItemId(item)}` ? item : null
);
}
it('restores a cached noise email into Noise but not Signal', () => {
const noiseEmail = inboxEmailItem('e-noise', false);
cacheEmail(noiseEmail);
const signalKey = seedInboxTabQuery('signal', [
inboxEmailItem('e-signal', true),
]);
const noiseKey = seedInboxTabQuery('noise', [
inboxEmailItem('e-old-noise', false),
]);
restoreSoupEntityToDoneFilteredQueries('e-noise');
const pageOf = (key: unknown[]) =>
testQueryClient
.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(key)!
.pages[0].items.map(getSoupItemId);
expect(pageOf(signalKey)).toEqual(['e-signal']);
expect(pageOf(noiseKey)).toEqual(['e-noise', 'e-old-noise']);
});
it('inserts a new signal email into Signal but not Noise', () => {
const signalKey = seedInboxTabQuery('signal', [
inboxEmailItem('e-signal', true),
]);
const noiseKey = seedInboxTabQuery('noise', [
inboxEmailItem('e-old-noise', false),
]);
insertSoupEntity(inboxEmailItem('e-new', true));
const pageOf = (key: unknown[]) =>
testQueryClient
.getQueryData<InfiniteData<SoupAstItemsFlatPage, unknown>>(key)!
.pages[0].items.map(getSoupItemId);
expect(pageOf(signalKey)).toEqual(['e-new', 'e-signal']);
expect(pageOf(noiseKey)).toEqual(['e-old-noise']);
});
});
/**
* `meta.insertFilter` gates admission only. Unlike `meta.itemFilter`, a
* rejection must never evict a row the server already returned — the gate is
* an approximation, so grouped membership sync keeps present rows intact.
*/
describe('insert gate (meta.insertFilter) — grouped cache', () => {
function seedGroupedAstQueryWithInsertFilter(
data: InfiniteData<SoupAstItemsGroupedPage, unknown>,
insertFilter: (item: SoupApiItem) => boolean,
suffix = 'grouped-insert-gated-seed'
) {
const key = [...soupKeys.astItems._def, {}, {}, STATUS_GROUP_BY, suffix];
testQueryClient.setQueryDefaults(key, {
meta: { groupBy: STATUS_GROUP_BY, insertFilter },
});
testQueryClient.setQueryData(key, data);
return key;
}
it('blocks admission of an absent item that fails the gate', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQueryWithInsertFilter(
mockGroupedParentCache(items, groups),
(item) => getSoupItemId(item) !== 'a-new'
);
insertSoupEntity(mockTaskItem('a-new', 'in_progress'));
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['a-new']).toBeUndefined();
expect(page.groups.find((g) => g.key === 'in_progress')!.itemIds).toEqual([
'a-1',
]);
});
it('keeps a present row that fails the gate through membership sync', () => {
const items = [mockTaskItem('a-1', 'in_progress')];
const groups = [buildGroup('in_progress', ['a-1'], 1, 0)];
const key = seedGroupedAstQueryWithInsertFilter(
mockGroupedParentCache(items, groups),
() => false
);
mockNormalizer.getObjectById.mockReturnValue(
mockTaskItem('a-1', 'in_progress')
);
optimisticUpdateSoupEntity(mockTaskItem('a-1', 'in_progress'));
const page =
testQueryClient.getQueryData<
InfiniteData<SoupAstItemsGroupedPage, unknown>
>(key)!.pages[0];
expect(page.items['a-1']).toBeDefined();
expect(page.groups.find((g) => g.key === 'in_progress')!.itemIds).toEqual([
'a-1',
]);
});
});
describe('raw grouped entity IDs', () => {
it('updates and removes memberships using entity IDs without changing pool keys', () => {
const item = mockTaskItem('a-1', 'in_progress');
const key = seedGroupedAstQuery({
pages: [
{
kind: 'grouped',
items: { 'a-1': item },
groups: [
buildGroup('in_progress', ['a-1'], 4),
buildGroup('done', [], 2),
],
nextCursor: null,
},
],
pageParams: [null],
});
const updated = mockTaskItem('a-1', 'done');
mockNormalizer.getObjectById.mockReturnValue(updated);
optimisticUpdateSoupEntity(updated);
const moved =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsGroupedPage>>(key)!
.pages[0];
expect(Object.keys(moved.items)).toEqual(['a-1']);
expect(moved.items['a-1']).toEqual(updated);
expect(
moved.groups.map((group) => [group.key, group.itemIds, group.totalCount])
).toEqual([
['in_progress', [], 3],
['done', ['a-1'], 3],
]);
const transaction = removeSoupEntities(new Set(['a-1']));
const removed =
testQueryClient.getQueryData<InfiniteData<SoupAstItemsGroupedPage>>(key)!
.pages[0];
expect(removed.items).toEqual({});
expect(removed.groups[1].itemIds).toEqual([]);
expect(removed.groups[1].totalCount).toBe(2);
transaction.rollback();
expect(
testQueryClient.getQueryData<InfiniteData<SoupAstItemsGroupedPage>>(key)!
.pages[0]
).toEqual(moved);
});
it('does not duplicate an entity from a later expanded-group page', () => {
const key = [...soupKeys.groupedGroup._def, 'raw-continuation'];
const item = mockTaskItem('a-1', 'in_progress');
type Page = { items: Record<string, SoupApiItem>; group: GroupMeta };
testQueryClient.setQueryDefaults(key, {
meta: { groupBy: STATUS_GROUP_BY, groupKey: 'in_progress' },
});
testQueryClient.setQueryData<InfiniteData<Page>>(key, {
pages: [
{
items: { 'a-2': mockTaskItem('a-2', 'in_progress') },
group: buildGroup('in_progress', ['a-2'], 5),
},
{
items: { 'a-1': item },
group: buildGroup('in_progress', ['a-1'], 5),
},
],
pageParams: [null, 'cursor'],
});
mockNormalizer.getObjectById.mockReturnValue(item);
optimisticUpdateSoupEntity(item);
insertSoupEntity(item);
const pages = testQueryClient.getQueryData<InfiniteData<Page>>(key)!.pages;
expect(pages.map((page) => page.group.itemIds)).toEqual([['a-2'], ['a-1']]);
removeSoupEntities(new Set(['a-1']));
const removed =
testQueryClient.getQueryData<InfiniteData<Page>>(key)!.pages;
expect(removed[1].items).toEqual({});
expect(removed[1].group.itemIds).toEqual([]);
expect(removed[1].group.totalCount).toBe(4);
});
});