@startsimpli/integrations 0.2.32 → 0.2.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/connection-activity.test.tsx

@@ -0,0 +1,160 @@
+/**
+ * THE CONNECTION CARD SAYS WHY A RUN FAILED (bd startsim-ei8gm.2, part 2).
+ *
+ * `ConnectionRun.error_message` has been DECLARED in this package's own types
+ * for as long as the endpoint has existed, and no component in
+ * `packages/integrations` or `apps/foundry` has ever read it. `connectionRuns`
+ * is likewise required on both api interfaces and called by nothing. So the
+ * activity endpoint that `#375` just taught to answer a real reason for source
+ * runs has no reader at all: a failed run does not render as a status word — it
+ * does not render.
+ *
+ * ONE COMPOSER, TWO SURFACES. `ConnectionsPage` is mounted by the control plane
+ * (`apps/foundry`'s `<ConnectionsPage api={api.foundry} foundrySlug={slug} />`)
+ * and by a tenant member's own screen in `personal` mode. The disclosure is
+ * gated on the VERB EXISTING — the rule the file already applies to Workflows
+ * and Settings — so an app pinned to an older `@startsimpli/api` degrades to no
+ * control rather than to a button whose handler is `undefined`.
+ *
+ * NOTHING IS SCRUBBED HERE. The text arrives already redacted against that
+ * connection's stored credential plus the platform app_secret
+ * (`apps/connectors/services/surface.py::_reason_reader` ->
+ * `dispatch.redaction_list`), and a run whose reason could not be proven clean
+ * arrives as a sentence saying so. A second redaction path in the browser would
+ * be a second thing to get wrong, and the browser does not hold the secrets to
+ * do it with.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { ConnectionsPage } from '../components/pages/ConnectionsPage';
+import type { ConnectionsApi, ConnectionRun } from '../components/pages/types';
+
+const CATALOG = {
+  results: [
+    {
+      key: 'granola', name: 'Granola', description: 'Meeting notes',
+      logo_url: '', docs_url: '', capabilities: ['poll'], auth_mode: 'api_key',
+      credential_schema: { version: 1, fields: [] },
+      config_schema: { version: 1, fields: [] },
+      record_types: [], supports_webhooks: false,
+      availability: { available: true, reason: '' },
+    },
+  ],
+};
+
+const CONNECTED = {
+  results: [
+    {
+      id: 'c1', public_id: 'pub1', name: 'Tandem Granola',
+      connector_key: 'granola', connector_name: 'Granola',
+      external_account_id: '', account_label: 'tandem',
+      capabilities_enabled: ['poll'], config: {}, status: 'connected',
+      health: 'ok', auth_mode: 'api_key',
+    },
+  ],
+  permissions: { view: true, manage: true, issue_tokens: true },
+};
+
+/** What production held, verbatim, for each of the twenty failed polls. */
+const THE_REAL_REASON =
+  'connector_granola poll failed on page 1: [config_error] the response '
+  + 'exceeded the 262144-byte cap and was aborted [granola]';
+
+const RUNS: ConnectionRun[] = [
+  {
+    id: 'r-new', kind: 'destination_run', object_id: 'd1', name: 'Corpus delivery',
+    status: 'completed', run_type: 'scheduled',
+    occurred_at: '2026-08-27T04:24:08Z', error_message: '',
+  },
+  {
+    id: 'r-old', kind: 'source_run', object_id: 's1', name: 'granola-poll',
+    status: 'failed', run_type: 'incremental',
+    occurred_at: '2026-08-12T20:21:46Z', error_message: THE_REAL_REASON,
+  },
+];
+
+function stubApi(overrides: Partial<ConnectionsApi> = {}): ConnectionsApi {
+  return {
+    connectorCatalog: vi.fn().mockResolvedValue(CATALOG),
+    connections: vi.fn().mockResolvedValue(CONNECTED),
+    connect: vi.fn(),
+    checkConnection: vi.fn().mockResolvedValue({ ok: true, account_label: '', detail: '' }),
+    disconnect: vi.fn(),
+    connectionChoices: vi.fn(),
+    wireTarget: vi.fn(),
+    confirmTarget: vi.fn(),
+    connectionActions: vi.fn(),
+    invokeConnectionAction: vi.fn(),
+    connectionRuns: vi.fn().mockResolvedValue({ results: RUNS }),
+    updateConnection: vi.fn(),
+    rotateCredential: vi.fn(),
+    ...overrides,
+  } as unknown as ConnectionsApi;
+}
+
+async function openActivity(api: ConnectionsApi = stubApi()) {
+  render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+  const button = await screen.findByRole('button', { name: /activity/i });
+  await userEvent.click(button);
+  return api;
+}
+
+describe('ConnectionCard — recent activity', () => {
+  it('has a control at all, which is the whole of the gap', async () => {
+    render(<ConnectionsPage api={stubApi()} foundrySlug="tandem" />);
+
+    expect(await screen.findByRole('button', { name: /activity/i })).toBeInTheDocument();
+  });
+
+  it('reads the runs endpoint that nothing has ever called', async () => {
+    const api = await openActivity();
+
+    await waitFor(() => expect(api.connectionRuns).toHaveBeenCalledWith('tandem', 'c1'));
+  });
+
+  it('renders the reason a failed run gives, not only its status word', async () => {
+    await openActivity();
+
+    expect(await screen.findByText(/262144-byte cap/)).toBeInTheDocument();
+  });
+
+  it('names which leg the run belongs to, since the card merges three tables', async () => {
+    await openActivity();
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/granola-poll/);
+    expect(activity).toHaveTextContent(/Corpus delivery/);
+  });
+
+  it('invents no reason for a run that succeeded', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [RUNS[0]] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).not.toHaveTextContent(/262144/);
+  });
+
+  it('says so when there is no activity, rather than rendering an empty box', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/no runs yet/i);
+  });
+
+  it('offers no control when the client is too old to have the verb', async () => {
+    // Apps consume `@startsimpli/*` as PUBLISHED packages, so a client pinned
+    // to an older `@startsimpli/api` is a normal state of the world. The gate
+    // is the verb existing — the same rule Workflows and Settings use.
+    const api = stubApi();
+    delete (api as Partial<ConnectionsApi>).connectionRuns;
+    render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+
+    await screen.findByText('Tandem Granola');
+    expect(screen.queryByRole('button', { name: /activity/i })).not.toBeInTheDocument();
+  });
+});

package/src/__tests__/corpus-narrowed-reads.test.ts

@@ -0,0 +1,337 @@
+/**
+ * THE CLIENT ASKS THE SERVER FOR A NARROWER ANSWER, AND CHECKS THAT IT GOT ONE.
+ *
+ * Two bugs, one root cause (bd startsim-o0o6o.2, bd startsim-o0o6o.3). The
+ * corpus adapter was written against a tenant data plane that filtered on
+ * `?type=` and nothing else, and several of its comments still assert that as
+ * fact. It has not been true since bd startsim-768w.38.12 and bd startsim-te3r:
+ * `RelationshipQuery` applies `entity__in` bounded at `MAX_ID_LIST` ids, and
+ * `TenantPageNumberPagination` honours `page_size` up to 200.
+ *
+ * WHY THE ANSWER IS CHECKED AND NOT ASSUMED. The tenant's response to a filter
+ * it does not recognise is an UNFILTERED PAGE with the parameter named in
+ * `ignored_filters` (bd startsim-768w.38.39) — not a 400 and not an empty list.
+ * So "send the filter and trust the rows" is the dangerous shape here: the reply
+ * to a narrowing request that was ignored looks exactly like a narrow answer
+ * with a lot of rows in it. start-simpli#154 set the precedent — read the
+ * server's own `applied_filters` and do not use an unconfirmed result — and the
+ * fakes below behave the way the wire behaves, ignoring what they do not support
+ * and answering as wide as they were asked.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { createCorpusApi } from '../corpus/client';
+import type { CorpusHttp } from '../corpus/client';
+import { startExtractionRun } from '../corpus/runs';
+import {
+  DEFAULT_RUN_KEY,
+  DEFAULT_TYPE_KEYS,
+  MAX_ID_LIST,
+  extractionRunToEntity,
+} from '../corpus/entities';
+import type { TenantEntity, TenantRelationship } from '../corpus/entities';
+import {
+  createFixtureCorpusApi,
+  createFixtureCorpusHttp,
+  createFixtureExtractor,
+  FIXTURE_ORG,
+  FIXTURE_SOURCE_LABELS,
+} from '../corpus/fixtures';
+import type { ExtractionRun, ExtractionRunStore } from '../corpus/types';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+
+function apiOver(overrides: Parameters<typeof createFixtureCorpusHttp>[0] = {}) {
+  const { http, requests } = createFixtureCorpusHttp(overrides);
+  const api = createCorpusApi({ http, scope: SCOPE, sourceLabels: FIXTURE_SOURCE_LABELS });
+  return { api, requests };
+}
+
+// ---------------------------------------------------------------------------
+//  bd startsim-o0o6o.3 — the sweep record, past the fifth row
+// ---------------------------------------------------------------------------
+
+function run(id: string): ExtractionRun {
+  return {
+    runId: id,
+    scope: SCOPE,
+    status: 'succeeded',
+    cursor: 4,
+    totalDocuments: 4,
+    totals: {
+      documentsProcessed: 4, fromRules: 2, fromModel: 1, ungrounded: 0, unconfirmed: 0,
+      created: 3, merged: 0, resolved: 0, droppedOutOfScope: 0, modelCalls: 4, modelFailures: 0,
+    },
+    processedIds: [],
+    modelIncompleteIds: [],
+    needsReview: [],
+    provider: { provider: 'fixture', model: 'fixture-rules', live: false },
+    startedAt: '2026-08-01T10:00:00Z',
+    updatedAt: '2026-08-01T10:06:00Z',
+    finishedAt: '2026-08-01T10:06:00Z',
+    leaseOwner: null,
+    leaseUntil: null,
+    error: null,
+    lastModelFailure: null,
+    history: [],
+  };
+}
+
+/** The singleton row, exactly as `writeRun` lands it. */
+function singleton(): TenantEntity {
+  return {
+    id: 'run-singleton',
+    ...extractionRunToEntity(run('sweep-1'), DEFAULT_TYPE_KEYS.extractionRun, DEFAULT_RUN_KEY),
+  };
+}
+
+/**
+ * Rows that are NOT the singleton, and which is which is not a hypothetical.
+ *
+ * A second workspace key, a renamed `runKey`, a partial migration or a
+ * hand-written row all put `extraction_run` rows next to it, and the tenant
+ * orders entities `-created_at` — so the singleton, which is the OLDEST because
+ * it was written first and is rewritten in place, sorts LAST. Newest first is
+ * the order these arrive in.
+ */
+function noise(count: number): TenantEntity[] {
+  return Array.from({ length: count }, (_, index) => ({
+    id: `run-noise-${index}`,
+    entity_type: DEFAULT_TYPE_KEYS.extractionRun,
+    external_id: `corpus-extraction-sweep-other-${index}`,
+    name: `Extraction sweep other-${index}`,
+    data: { run: JSON.stringify(run(`other-${index}`)), _origin: 'tenant-extraction' },
+  }));
+}
+
+describe('readRun tells "nothing has ever run" apart from "I could not tell"', () => {
+  it('finds the singleton when it is NOT among the newest five rows', async () => {
+    // Six rows, singleton last: the exact corpus at which `page_size: 5` starts
+    // answering `null` — which every caller reads as "no sweep has ever run" and
+    // `startExtractionRun` acts on by starting a duplicate sweep.
+    const { api } = apiOver({ entities: [...noise(5), singleton()], relationships: [] });
+
+    const read = await api.readRun();
+
+    expect(read?.runId).toBe('sweep-1');
+  });
+
+  it('THROWS rather than reporting "never run" when the row could be past the cap', async () => {
+    // Past the server's own `max_page_size`, one read genuinely cannot see every
+    // row — and the honest answer to "has a sweep run here" is then neither the
+    // run nor `null`. `null` is a FACT in this contract; a truncated page is not
+    // evidence for it.
+    const { api } = apiOver({
+      entities: [...noise(MAX_ID_LIST + 20), singleton()],
+      relationships: [],
+    });
+
+    await expect(api.readRun()).rejects.toThrow(/could not/i);
+  });
+
+  it('still answers null for a workspace where nothing HAS run', async () => {
+    // The fact this whole contract exists to preserve: absence is reportable.
+    const { api } = apiOver({ entities: [], relationships: [] });
+
+    expect(await api.readRun()).toBeNull();
+  });
+
+  it('matches the singleton key in EITHER spelling the wire delivers it in', async () => {
+    // `@startsimpli/api`'s fetch wrapper transforms every response key
+    // snake_case -> camelCase, so a browser-side read of this row carries
+    // `externalId` and never `external_id`. This lookup read one spelling, so in
+    // the browser it matched nothing at ANY page size and reported "never run"
+    // over a workspace with a sweep in it — the same seam, and the same lie, as
+    // reading one spelling of `applied_filters`.
+    const { external_id: key, ...rest } = singleton();
+    const { api } = apiOver({
+      entities: [{ ...rest, externalId: key }],
+      relationships: [],
+    });
+
+    expect((await api.readRun())?.runId).toBe('sweep-1');
+  });
+
+  it('asks for the widest page the server will serve, not five rows', async () => {
+    const { api, requests } = apiOver({ entities: [singleton()], relationships: [] });
+    await api.readRun();
+
+    const read = requests.find(
+      (request) => request.params.type === DEFAULT_TYPE_KEYS.extractionRun,
+    );
+    expect(read?.params.page_size).toBe(MAX_ID_LIST);
+  });
+});
+
+// ---------------------------------------------------------------------------
+//  bd startsim-o0o6o.2 — the edges of ONE PAGE, not the whole edge table
+// ---------------------------------------------------------------------------
+
+const PARTY: TenantEntity = {
+  id: 'party_dana', entity_type: 'party', external_id: 'granola:dana@example.com',
+  name: 'Dana Reed',
+  data: { display_name: 'Dana Reed', email: 'dana@example.com', source: 'granola' },
+};
+
+function document(id: string): TenantEntity {
+  return {
+    id, entity_type: 'source_document', external_id: `granola:${id}`, name: `Record ${id}`,
+    data: { source: 'granola', title: `Record ${id}`, occurred_at: '2026-08-01T09:00:00Z' },
+  };
+}
+
+describe('the participant join reads the edges of a PAGE, not the edge table', () => {
+  it('names the page’s ids in entity__in instead of asking for everything', async () => {
+    const { api, requests } = apiOver();
+    await api.listDocuments({ page: 1, pageSize: 3 });
+
+    const edgeReads = requests.filter((request) => request.path.includes('relationships'));
+    expect(edgeReads.length).toBeGreaterThan(0);
+    // THE ASSERTION THIS FILE EXISTS FOR. `readAll(relationships, {})` sent no
+    // parameters at all and walked up to twenty pages of every edge in the
+    // workspace, on a comment claiming the endpoint had no filters.
+    for (const read of edgeReads) {
+      const named = String(read.params.entity__in ?? '').split(',').filter(Boolean);
+      expect(named.length).toBeGreaterThan(0);
+      expect(named.length).toBeLessThanOrEqual(MAX_ID_LIST);
+    }
+    expect(String(edgeReads[0].params.entity__in).split(',')).toHaveLength(3);
+  });
+
+  it('still resolves the people on the page it narrowed to', async () => {
+    const { api } = apiOver({
+      entities: [document('doc-1'), PARTY],
+      relationships: [{ id: 'e1', rel_type: 'authored_by', source: 'doc-1', target: 'party_dana' }],
+    });
+
+    const page = await api.listDocuments({ page: 1 });
+
+    expect(page.results[0].participants.map((party) => party.name)).toEqual(['Dana Reed']);
+  });
+
+  it('chunks a page wider than the server’s id bound rather than being refused', async () => {
+    // A fork whose `max_page_size` is larger than `MAX_ID_LIST` hands back more
+    // ids than one `entity__in` may carry, and `_uuid_list` answers a longer
+    // list with a 400 — so the ids are chunked. Truncating them instead would
+    // drop the people off the tail of the page silently, which is the failure
+    // this whole change is undoing.
+    const documents = Array.from({ length: MAX_ID_LIST + 40 }, (_, index) =>
+      document(`doc-${index}`),
+    );
+    const last = documents[documents.length - 1];
+    const { api, requests } = apiOver({
+      pageSize: documents.length,
+      entities: [...documents, PARTY],
+      relationships: [
+        { id: 'e-last', rel_type: 'involves', source: String(last.id), target: 'party_dana' },
+      ],
+    });
+
+    const page = await api.listDocuments({ page: 1 });
+
+    const edgeReads = requests.filter((request) => request.path.includes('relationships'));
+    expect(edgeReads.length).toBeGreaterThan(1);
+    for (const read of edgeReads) {
+      expect(String(read.params.entity__in).split(',').length).toBeLessThanOrEqual(MAX_ID_LIST);
+    }
+    const tail = page.results.find((record) => record.id === String(last.id));
+    expect(tail?.participants.map((party) => party.name)).toEqual(['Dana Reed']);
+  });
+});
+
+/**
+ * A fork that has NOT shipped `RelationshipQuery`.
+ *
+ * It does what the tenant documents itself as doing with a parameter it does not
+ * know: names it in `ignored_filters` and answers with the page exactly as wide
+ * as it was. A fake that returned `[]` here would let the client pass this suite
+ * while reading the whole edge table in production, which is the trap this test
+ * is written to spring.
+ */
+function unfilteredEdgeHttp(edges: TenantRelationship[], rows: TenantEntity[]) {
+  const requests: Array<{ path: string; params: Record<string, unknown> }> = [];
+  const http: CorpusHttp = {
+    async get<T>(path: string, init?: { params?: Record<string, unknown> }): Promise<T> {
+      const params = init?.params ?? {};
+      requests.push({ path, params });
+      if (path.includes('relationships')) {
+        return {
+          count: edges.length, next: null, previous: null, results: edges,
+          applied_filters: [],
+          ignored_filters: Object.keys(params).filter(
+            (key) => key !== 'page' && key !== 'page_size',
+          ),
+        } as T;
+      }
+      if (path.includes('entities')) {
+        const type = params.type ? String(params.type) : '';
+        const matching = type ? rows.filter((row) => row.entity_type === type) : rows;
+        return {
+          count: matching.length, next: null, previous: null, results: matching,
+          applied_filters: [],
+          ignored_filters: [],
+        } as T;
+      }
+      throw Object.assign(new Error(`${path} responded 404`), { status: 404 });
+    },
+  };
+  return { http, requests };
+}
+
+describe('an unconfirmed narrowing is not used', () => {
+  it('renders no participants rather than joining an unnarrowed page of edges', async () => {
+    // start-simpli#154's precedent, on the read that matters most: the server
+    // reported it did NOT apply `entity__in`, so the rows it sent are an
+    // arbitrary page of the whole edge table and joining them would put the
+    // wrong people — or a partial list of the right ones — on the record. The
+    // Library degrades to what it showed before the join existed.
+    const { http, requests } = unfilteredEdgeHttp(
+      [{ id: 'e1', rel_type: 'authored_by', source: 'doc-1', target: 'party_dana' }],
+      [document('doc-1'), PARTY],
+    );
+    const api = createCorpusApi({ http, scope: SCOPE, sourceLabels: FIXTURE_SOURCE_LABELS });
+
+    const page = await api.listDocuments({ page: 1 });
+
+    expect(page.results).toHaveLength(1);
+    expect(page.results[0].participants).toEqual([]);
+    // And it does not go on to read the party roster for a join it will not do.
+    expect(requests.filter((request) => request.params.type === 'party')).toHaveLength(0);
+  });
+});
+
+describe('a store that could not answer never becomes "no sweep has ever run"', () => {
+  it('refuses to start a second sweep over a cursor it was unable to read', async () => {
+    // THE REASON THE THIRD ANSWER HAD TO REACH THIS CALLER. `startExtractionRun`
+    // swallowed every `readRun` failure into `null` and `null` means "start a
+    // new sweep" one branch later, so an undetermined read put a SECOND driver
+    // on a live cursor — and two model calls over one document produce two
+    // differently-worded items dedupe cannot see are the same, which is how a
+    // live re-run once turned 82 commitments into 98.
+    let writes = 0;
+    const runs: ExtractionRunStore = {
+      async readRun() {
+        throw Object.assign(
+          new Error('Could not determine whether a sweep has run in this workspace.'),
+          { status: 409 },
+        );
+      },
+      async writeRun(run) {
+        writes += 1;
+        return run;
+      },
+    };
+
+    await expect(
+      startExtractionRun(
+        { scope: SCOPE },
+        {
+          corpus: createFixtureCorpusApi({ scope: SCOPE }),
+          extractor: createFixtureExtractor(),
+          runs,
+        },
+      ),
+    ).rejects.toThrow(/could not determine/i);
+    expect(writes).toBe(0);
+  });
+});

package/src/__tests__/corpus-storage.test.ts

@@ -191,8 +191,10 @@ describe('both storage shapes, because both are real', () => {
   });
 });
 
-describe('the graph read is bounded, cached and fails soft', () => {
-  it('costs ONE graph read across a list, a detail and a second page', async () => {
+describe('the graph read is narrowed, cached and fails soft', () => {
+  it('costs ONE edge read across a list, a detail and a second page', async () => {
+    // The records are remembered per row, so re-listing them and then opening
+    // one of them asks the server nothing further (bd startsim-o0o6o.2).
     const { api, requests } = apiOver();
     await api.listDocuments({ page: 1 });
     await api.listDocuments({ page: 1 });
@@ -220,17 +222,26 @@ describe('the graph read is bounded, cached and fails soft', () => {
     expect(page.results.every((document) => document.participants.length === 0)).toBe(true);
   });
 
-  it('walks every page of the graph, since the tenant ignores page_size', async () => {
-    // Two rows a page: the edges for the last document are only reachable by
-    // paging, which is exactly what the real PAGE_SIZE=50 does at scale.
+  it('narrows the edge read to the ids of the page it is rendering', async () => {
+    // THIS TEST USED TO ASSERT THE OPPOSITE, and its title said why: "walks
+    // every page of the graph, since the tenant ignores page_size". Neither half
+    // survived contact with the deployed server. `page_size` is honoured
+    // (`TenantPageNumberPagination`, bd startsim-768w.38.12) and the edge table
+    // is filterable (`RelationshipQuery`, bd startsim-te3r) — so a page deep in
+    // the corpus no longer reaches its people by reading every edge in the
+    // workspace and joining in the browser. It ASKS for the edges of the two
+    // rows it is rendering, which is the read that scales with the page instead
+    // of with the corpus (bd startsim-o0o6o.2).
     const { api, requests } = apiOver({ pageSize: 2 });
-    // `pageSize: 100` is ignored by the server, exactly as the tenant ignores
-    // it — so the Dropbox row is on page THREE however wide the caller asked.
-    const page = await api.listDocuments({ page: 3, pageSize: 100 });
+    const page = await api.listDocuments({ page: 3 });
     const dropbox = page.results.find((document) => document.id === 'dbx_9812f0');
 
     expect(dropbox?.participants.map((party) => party.name)).toEqual(['Acme Robotics', 'Dana Reed']);
-    expect(requests.filter((request) => request.path.includes('relationships')).length).toBeGreaterThan(1);
+    const edgeReads = requests.filter((request) => request.path.includes('relationships'));
+    expect(edgeReads).toHaveLength(1);
+    expect(String(edgeReads[0].params.entity__in).split(',')).toEqual(
+      page.results.map((document) => document.id),
+    );
   });
 });