Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

68.8 KB
Raw Blame
/**
 * @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);
  });
});