@pih/esm-audit-app 2.1.1-pre.144 → 2.1.1-pre.151

package/src/audit/user-encounters.test.ts

@@ -0,0 +1,176 @@
+import { type AuditObs } from '../types';
+import {
+  canDiscoverMore,
+  countUserObs,
+  discoverEncounters,
+  emptyStream,
+  filterByEncounterType,
+  type ObsStream,
+  streamToExtend,
+} from './user-encounters';
+
+const consultation = { uuid: 'enc-1', encounterType: { uuid: 'type-1', display: 'Oncology Consultation' } };
+const checkin = { uuid: 'enc-2', encounterType: { uuid: 'type-2', display: 'Inscription' } };
+const vitals = { uuid: 'enc-3', encounterType: { uuid: 'type-3', display: 'Vitals' } };
+
+/** A day in September 2026, as the REST API would report it. */
+function day(dayOfMonth: number): string {
+  return `2026-09-${String(dayOfMonth).padStart(2, '0')}T08:00:00.000+0000`;
+}
+
+function created(uuid: string, encounter: unknown, when: string): AuditObs {
+  return { uuid, encounter: encounter as AuditObs['encounter'], auditInfo: { dateCreated: when } };
+}
+
+function voided(uuid: string, encounter: unknown, when: string): AuditObs {
+  return { uuid, encounter: encounter as AuditObs['encounter'], auditInfo: { dateVoided: when } };
+}
+
+function stream(obs: Array<AuditObs>, exhausted = true): ObsStream {
+  return { obs, exhausted };
+}
+
+/** A search that returned nothing and has nothing more to give. */
+const exhaustedStream: ObsStream = { obs: [], exhausted: true };
+
+describe('discoverEncounters', () => {
+  it('collapses the observations of one encounter into a single row', () => {
+    const activity = discoverEncounters(
+      stream([created('obs-1', consultation, day(1)), created('obs-2', consultation, day(2))]),
+      exhaustedStream,
+    );
+
+    expect(activity).toHaveLength(1);
+    expect(activity[0].encounter.uuid).toBe('enc-1');
+  });
+
+  it('takes the most recent change as an encounter’s last activity', () => {
+    const activity = discoverEncounters(
+      stream([created('obs-1', consultation, day(1))]),
+      stream([voided('obs-2', consultation, day(7))]),
+    );
+
+    expect(activity[0].lastActivity).toBe(day(7));
+  });
+
+  it('merges the two searches into one order, most recently changed first', () => {
+    const activity = discoverEncounters(
+      stream([created('obs-1', vitals, day(6)), created('obs-2', consultation, day(2))]),
+      stream([voided('obs-3', checkin, day(4))]),
+    );
+
+    expect(activity.map((entry) => entry.encounter.uuid)).toEqual(['enc-3', 'enc-2', 'enc-1']);
+  });
+
+  it('leaves out observations that belong to no encounter, having no trail to open', () => {
+    expect(discoverEncounters(stream([created('obs-1', undefined, day(1))]), exhaustedStream)).toEqual([]);
+  });
+
+  /**
+   * The point of reading lazily: a partly-read stream must not offer an encounter whose place a row
+   * further down could still take, or the first page would reshuffle as the second was read.
+   */
+  it('withholds encounters that an unread row could still outrank', () => {
+    const partial = stream([created('obs-1', consultation, day(9)), created('obs-2', checkin, day(5))], false);
+
+    const activity = discoverEncounters(partial, exhaustedStream);
+
+    // enc-2 sits at the boundary, so only enc-1 is certainly placed
+    expect(activity.map((entry) => entry.encounter.uuid)).toEqual(['enc-1']);
+  });
+
+  it('offers everything once both searches are exhausted', () => {
+    const activity = discoverEncounters(
+      stream([created('obs-1', consultation, day(9)), created('obs-2', checkin, day(5))]),
+      exhaustedStream,
+    );
+
+    expect(activity.map((entry) => entry.encounter.uuid)).toEqual(['enc-1', 'enc-2']);
+  });
+
+  it('trusts nothing while a search has not been read at all', () => {
+    const activity = discoverEncounters(stream([created('obs-1', consultation, day(9))]), emptyStream);
+
+    // the voided search is unread rather than exhausted, so its first row could outrank enc-1
+    expect(activity).toEqual([]);
+  });
+
+  it('trusts only as far as the search that has been read least far', () => {
+    const activity = discoverEncounters(
+      stream([created('obs-1', consultation, day(9))], false),
+      stream([voided('obs-2', checkin, day(3))], false),
+    );
+
+    // the created search is read only to day 9, so nothing at or below that is certain yet
+    expect(activity).toEqual([]);
+  });
+});
+
+describe('streamToExtend', () => {
+  it('reads from whichever search is holding the boundary up', () => {
+    // read only as far as day 9, so this one is holding the boundary up
+    const createdBehind = stream([created('obs-1', consultation, day(9))], false);
+    const voidedAhead = stream([voided('obs-2', checkin, day(3))], false);
+    expect(streamToExtend(createdBehind, voidedAhead)).toBe('created');
+
+    // and the other way round
+    const createdAhead = stream([created('obs-3', checkin, day(3))], false);
+    const voidedBehind = stream([voided('obs-4', consultation, day(9))], false);
+    expect(streamToExtend(createdAhead, voidedBehind)).toBe('voided');
+  });
+
+  it('reads from the other one when a search is exhausted', () => {
+    expect(streamToExtend(stream([], true), stream([], false))).toBe('voided');
+    expect(streamToExtend(stream([], false), stream([], true))).toBe('created');
+  });
+
+  it('has nothing left to read once both are exhausted', () => {
+    expect(streamToExtend(stream([], true), stream([], true))).toBeNull();
+    expect(canDiscoverMore(stream([], true), stream([], true))).toBe(false);
+    expect(canDiscoverMore(stream([], true), stream([], false))).toBe(true);
+  });
+});
+
+describe('countUserObs', () => {
+  const user = 'user-1';
+  const other = 'user-2';
+  const obs = (creator: string, voidedBy?: string): AuditObs => ({
+    uuid: `obs-${Math.random()}`,
+    auditInfo: {
+      creator: { uuid: creator },
+      ...(voidedBy ? { voidedBy: { uuid: voidedBy } } : {}),
+    },
+  });
+
+  it('counts what the user recorded and what they deleted', () => {
+    expect(countUserObs([obs(user), obs(user), obs(other, user)], user)).toEqual({ obsCreated: 2, obsVoided: 1 });
+  });
+
+  it('counts an observation the user both recorded and deleted in each column', () => {
+    expect(countUserObs([obs(user, user)], user)).toEqual({ obsCreated: 1, obsVoided: 1 });
+  });
+
+  it('ignores what other users did to the same encounter', () => {
+    expect(countUserObs([obs(other), obs(other, other)], user)).toEqual({ obsCreated: 0, obsVoided: 0 });
+  });
+});
+
+describe('filterByEncounterType', () => {
+  const activity = [
+    { encounter: consultation, lastActivity: day(9) },
+    { encounter: checkin, lastActivity: day(5) },
+    { encounter: { uuid: 'enc-4' }, lastActivity: day(4) },
+  ];
+
+  it('keeps everything when no type is chosen', () => {
+    expect(filterByEncounterType(activity, undefined)).toBe(activity);
+  });
+
+  it('keeps only encounters of the chosen type', () => {
+    expect(filterByEncounterType(activity, 'type-1').map((entry) => entry.encounter.uuid)).toEqual(['enc-1']);
+  });
+
+  it('leaves out an encounter whose type the api did not report', () => {
+    expect(filterByEncounterType(activity, 'type-3')).toEqual([]);
+  });
+});

package/src/audit/user-encounters.ts

@@ -0,0 +1,166 @@
+import { type AuditEncounter, type AuditObs } from '../types';
+
+/** Which audit action a stream of observations was searched by. */
+export type AuditAction = 'created' | 'voided';
+
+/** What has been read of one of the two audit searches so far. */
+export interface ObsStream {
+  /** Rows read so far, in the order the endpoint returned them: audit date descending. */
+  obs: Array<AuditObs>;
+  /** True once a short page came back, meaning there is nothing further to read. */
+  exhausted: boolean;
+}
+
+export const emptyStream: ObsStream = { obs: [], exhausted: false };
+
+/** What one user did to the observations of one encounter. */
+export interface UserEncounterActivity {
+  encounter: AuditEncounter;
+  /** The most recent action, which is what the list is ordered by. */
+  lastActivity: string;
+  /** How many of the encounter's observations the user recorded, once counted exactly. */
+  obsCreated?: number;
+  /** How many of the encounter's observations the user deleted, once counted exactly. */
+  obsVoided?: number;
+}
+
+/** When the audit action behind an observation happened, in the stream it came from. */
+export function actionTime(obs: AuditObs, action: AuditAction): string {
+  return (action === 'created' ? obs.auditInfo?.dateCreated : obs.auditInfo?.dateVoided) ?? '';
+}
+
+/**
+ * Sorts after any ISO date, standing for a stream whose position is not yet known at all: one that
+ * has been read no further than its start and still has rows to come. Such a stream constrains
+ * everything, since its very first unread row could outrank anything already discovered.
+ */
+const unreadWatermark = '\uffff';
+
+/**
+ * How far down a stream has been read, as the audit date of its last row.
+ *
+ * `null` means the stream constrains nothing, because it is exhausted. That is deliberately
+ * different from a stream that has simply not been read yet, which constrains everything — a
+ * distinction worth keeping, since conflating the two would let the list trust an order that a
+ * search nobody has run could still overturn.
+ */
+function watermark(stream: ObsStream, action: AuditAction): string | null {
+  if (stream.exhausted) {
+    return null;
+  }
+  if (stream.obs.length === 0) {
+    return unreadWatermark;
+  }
+  return actionTime(stream.obs[stream.obs.length - 1], action) || unreadWatermark;
+}
+
+/** How far the merged order can be trusted, or null when both streams are exhausted. */
+function discoveryBoundary(created: ObsStream, voided: ObsStream): string | null {
+  const marks = [watermark(created, 'created'), watermark(voided, 'voided')].filter(
+    (mark): mark is string => mark !== null,
+  );
+  return marks.length === 0 ? null : marks.sort().pop();
+}
+
+/**
+ * The stream to read from next, being whichever is holding the discovery boundary up. Reading the
+ * other one cannot reveal an encounter that belongs higher in the list.
+ */
+export function streamToExtend(created: ObsStream, voided: ObsStream): AuditAction | null {
+  if (created.exhausted && voided.exhausted) {
+    return null;
+  }
+  if (created.exhausted) {
+    return 'voided';
+  }
+  if (voided.exhausted) {
+    return 'created';
+  }
+  return (watermark(created, 'created') ?? '') >= (watermark(voided, 'voided') ?? '') ? 'created' : 'voided';
+}
+
+/**
+ * The encounters discoverable from what has been read, most recently changed first.
+ *
+ * Both searches return observations by audit date descending, so the first time an encounter
+ * appears in the merged stream is its most recent change — which means encounters come out of the
+ * merge already in the order the list wants them, without having to read to the end of either
+ * search.
+ *
+ * What has *not* been read still constrains the answer. An observation not yet read can only be
+ * older than the last row read from its stream, so any encounter first seen later than both
+ * streams' positions is certain to be correctly placed; one at or below that boundary might still
+ * be overtaken by a row further down. Only the certain ones are returned, so a page never reorders
+ * itself as more is read.
+ */
+export function discoverEncounters(created: ObsStream, voided: ObsStream): Array<UserEncounterActivity> {
+  const boundary = discoveryBoundary(created, voided);
+
+  const firstSeen = new Map<string, UserEncounterActivity>();
+  const consider = (stream: ObsStream, action: AuditAction) => {
+    for (const obs of stream.obs) {
+      const encounter = obs.encounter as AuditEncounter | undefined;
+      // An observation can exist outside an encounter, and there is no encounter audit trail to
+      // show for one, so it cannot appear in a list of encounters.
+      if (!encounter?.uuid) {
+        continue;
+      }
+      const when = actionTime(obs, action);
+      const existing = firstSeen.get(encounter.uuid);
+      if (!existing) {
+        firstSeen.set(encounter.uuid, { encounter, lastActivity: when });
+      } else if (when > existing.lastActivity) {
+        existing.lastActivity = when;
+      }
+    }
+  };
+  consider(created, 'created');
+  consider(voided, 'voided');
+
+  return Array.from(firstSeen.values())
+    .filter((activity) => boundary === null || activity.lastActivity > boundary)
+    .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity) || a.encounter.uuid.localeCompare(b.encounter.uuid));
+}
+
+/**
+ * Narrows discovered encounters to one encounter type.
+ *
+ * The audit endpoint takes no encounter type parameter, so this is applied after the merge rather
+ * than by the server. That means a rare type may need much of the trail read before a page's worth
+ * of it is found, which is why the scan reports when it stopped early.
+ */
+export function filterByEncounterType(
+  activity: Array<UserEncounterActivity>,
+  encounterTypeUuid: string | undefined,
+): Array<UserEncounterActivity> {
+  if (!encounterTypeUuid) {
+    return activity;
+  }
+  return activity.filter((entry) => entry.encounter.encounterType?.uuid === encounterTypeUuid);
+}
+
+/** Whether reading further could reveal more encounters. */
+export function canDiscoverMore(created: ObsStream, voided: ObsStream): boolean {
+  return !created.exhausted || !voided.exhausted;
+}
+
+/**
+ * How many of an encounter's observations the given user recorded and deleted.
+ *
+ * The audit search cannot be narrowed to one encounter, so the counts come from reading the
+ * encounter's own observations and attributing them — which is exact, and only done for the rows
+ * actually on screen.
+ */
+export function countUserObs(obsList: Array<AuditObs>, userUuid: string): { obsCreated: number; obsVoided: number } {
+  let obsCreated = 0;
+  let obsVoided = 0;
+  for (const obs of obsList) {
+    if (obs.auditInfo?.creator?.uuid === userUuid) {
+      obsCreated += 1;
+    }
+    if (obs.auditInfo?.voidedBy?.uuid === userUuid) {
+      obsVoided += 1;
+    }
+  }
+  return { obsCreated, obsVoided };
+}

package/src/audit/user-search.component.test.tsx

@@ -0,0 +1,89 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { SWRConfig } from 'swr';
+import { openmrsFetch } from '@openmrs/esm-framework';
+import UserSearch from './user-search.component';
+
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+
+const mockUsers = [
+  {
+    uuid: 'user-1',
+    display: 'butch',
+    username: 'butch',
+    systemId: '3-4',
+    person: { uuid: 'person-1', display: 'Cos John' },
+  },
+  {
+    uuid: 'user-2',
+    display: 'retired.clerk',
+    username: 'retired.clerk',
+    retired: true,
+    person: { uuid: 'person-2', display: 'Old Clerk' },
+  },
+];
+
+function renderUserSearch() {
+  const onSelectUser = jest.fn();
+  render(
+    <SWRConfig value={{ dedupingInterval: 0, provider: () => new Map() }}>
+      <UserSearch onSelectUser={onSelectUser} />
+    </SWRConfig>,
+  );
+  return onSelectUser;
+}
+
+describe('<UserSearch />', () => {
+  beforeEach(() => {
+    mockOpenmrsFetch.mockResolvedValue({
+      data: { results: mockUsers, totalCount: 2 },
+    } as unknown as ReturnType<typeof openmrsFetch>);
+  });
+
+  it('asks for a search term before searching', () => {
+    renderUserSearch();
+
+    expect(screen.getByText(/enter a name or username/i)).toBeInTheDocument();
+    expect(mockOpenmrsFetch).not.toHaveBeenCalled();
+  });
+
+  it('searches users by name or username and lists what it finds', async () => {
+    renderUserSearch();
+
+    await userEvent.type(screen.getByRole('searchbox'), 'butch');
+
+    expect(await screen.findByRole('button', { name: 'Cos John' })).toBeInTheDocument();
+    expect(screen.getByRole('cell', { name: 'butch' })).toBeInTheDocument();
+    expect(mockOpenmrsFetch).toHaveBeenCalledWith(expect.stringContaining('/ws/rest/v1/user?q=butch'));
+  });
+
+  it('marks a retired account, since it can still own an audit trail', async () => {
+    renderUserSearch();
+
+    await userEvent.type(screen.getByRole('searchbox'), 'clerk');
+
+    const retiredRow = (await screen.findAllByRole('row')).find((row) => row.textContent?.includes('Old Clerk'));
+    expect(retiredRow).toHaveTextContent('Retired');
+  });
+
+  it('drills down into the user that is clicked', async () => {
+    const onSelectUser = renderUserSearch();
+
+    await userEvent.type(screen.getByRole('searchbox'), 'butch');
+    await userEvent.click(await screen.findByRole('button', { name: 'Cos John' }));
+
+    expect(onSelectUser).toHaveBeenCalledWith('user-1');
+  });
+
+  it('says so when nothing matches', async () => {
+    mockOpenmrsFetch.mockResolvedValue({ data: { results: [], totalCount: 0 } } as unknown as ReturnType<
+      typeof openmrsFetch
+    >);
+    renderUserSearch();
+
+    await userEvent.type(screen.getByRole('searchbox'), 'nobody');
+
+    expect(await screen.findByText(/no users match "nobody"/i)).toBeInTheDocument();
+  });
+});

package/src/audit/user-search.component.tsx

@@ -0,0 +1,111 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  DataTableSkeleton,
+  Pagination,
+  Search,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Tag,
+} from '@carbon/react';
+import { ErrorState, useConfig, useDebounce } from '@openmrs/esm-framework';
+import { type Config } from '../config-schema';
+import { useUserSearch } from './audit.resource';
+import styles from './audit.scss';
+
+interface UserSearchProps {
+  onSelectUser(userUuid: string): void;
+}
+
+/**
+ * Finds the user account whose work is being audited, by username or by the person's name.
+ */
+export default function UserSearch({ onSelectUser }: UserSearchProps) {
+  const { t } = useTranslation();
+  const config = useConfig<Config>();
+  const [searchTerm, setSearchTerm] = useState('');
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(config.patientSearchPageSize ?? 10);
+  const debouncedSearchTerm = useDebounce(searchTerm.trim(), 300);
+  const pageSizes = useMemo(() => Array.from(new Set([pageSize, 10, 20, 50])).sort((a, b) => a - b), [pageSize]);
+  const { users, totalCount, error, isLoading } = useUserSearch(debouncedSearchTerm, page, pageSize);
+
+  useEffect(() => {
+    setPage(1);
+  }, [debouncedSearchTerm]);
+
+  return (
+    <div>
+      <Search
+        className={styles.searchInput}
+        labelText={t('searchForUser', 'Search for a user by name or username')}
+        onChange={(event) => setSearchTerm(event.target.value)}
+        placeholder={t('searchForUser', 'Search for a user by name or username')}
+        size="lg"
+        value={searchTerm}
+      />
+      {!debouncedSearchTerm ? (
+        <p className={styles.emptyState}>
+          {t('searchUserToBegin', 'Enter a name or username to see the encounters that user has modified.')}
+        </p>
+      ) : error ? (
+        <ErrorState error={error} headerTitle={t('userSearchResults', 'User search results')} />
+      ) : isLoading ? (
+        <DataTableSkeleton columnCount={3} compact role="progressbar" showHeader={false} showToolbar={false} />
+      ) : users.length === 0 ? (
+        <p className={styles.emptyState}>
+          {t('noUsersFound', 'No users match "{{searchTerm}}".', { searchTerm: debouncedSearchTerm })}
+        </p>
+      ) : (
+        <>
+          <TableContainer className={styles.tableContainer}>
+            <Table size="sm" useZebraStyles>
+              <TableHead>
+                <TableRow>
+                  <TableHeader>{t('name', 'Name')}</TableHeader>
+                  <TableHeader>{t('username', 'Username')}</TableHeader>
+                  <TableHeader>{t('status', 'Status')}</TableHeader>
+                </TableRow>
+              </TableHead>
+              <TableBody>
+                {users.map((user) => (
+                  <TableRow className={styles.clickableRow} key={user.uuid} onClick={() => onSelectUser(user.uuid)}>
+                    <TableCell>
+                      <button
+                        className={styles.linkButton}
+                        onClick={(event) => {
+                          event.stopPropagation();
+                          onSelectUser(user.uuid);
+                        }}
+                        type="button">
+                        {user.person?.display ?? user.display}
+                      </button>
+                    </TableCell>
+                    <TableCell>{user.username ?? user.systemId}</TableCell>
+                    <TableCell>{user.retired ? <Tag type="gray">{t('retired', 'Retired')}</Tag> : null}</TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </TableContainer>
+          <Pagination
+            onChange={({ page: nextPage, pageSize: nextPageSize }) => {
+              setPage(nextPage);
+              setPageSize(nextPageSize);
+            }}
+            page={page}
+            pageSize={pageSize}
+            pageSizes={pageSizes}
+            size="sm"
+            totalItems={totalCount}
+          />
+        </>
+      )}
+    </div>
+  );
+}

package/src/root.component.test.tsx

@@ -1,11 +1,11 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { SWRConfig } from 'swr';
-import { openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import { openmrsFetch } from '@openmrs/esm-framework';
 import Root from './root.component';
 
 const mockOpenmrsFetch = jest.mocked(openmrsFetch);
-const mockUseConfig = jest.mocked(useConfig);
 
 function renderRoot(url = '/') {
   window.history.pushState({}, '', url);
@@ -18,13 +18,28 @@ function renderRoot(url = '/') {
 
 describe('<Root />', () => {
   beforeEach(() => {
-    mockUseConfig.mockReturnValue({ patientChartUrl: '${openmrsSpaBase}/patient/${patientUuid}/chart' });
     mockOpenmrsFetch.mockImplementation((url: string) => {
       if (url.includes('/patient/patient-1')) {
         return Promise.resolve({
           data: { uuid: 'patient-1', display: 'Y2AHXV - Dave TestPatient', person: { display: 'Dave TestPatient' } },
         }) as ReturnType<typeof openmrsFetch>;
       }
+      if (url.includes('/pihapps/obs?')) {
+        return Promise.resolve({ data: { results: [] } }) as ReturnType<typeof openmrsFetch>;
+      }
+      if (url.includes('/user/user-1')) {
+        return Promise.resolve({
+          data: { uuid: 'user-1', display: 'butch', username: 'butch', person: { display: 'Cos John' } },
+        }) as ReturnType<typeof openmrsFetch>;
+      }
+      if (url.includes('/provider/prov-1')) {
+        return Promise.resolve({
+          data: { uuid: 'prov-1', display: 'MCPRPG - Louidor Jean paul', identifier: 'MCPRPG' },
+        }) as ReturnType<typeof openmrsFetch>;
+      }
+      if (url.includes('/pihapps/encounter?')) {
+        return Promise.resolve({ data: { results: [], totalCount: 0 } }) as ReturnType<typeof openmrsFetch>;
+      }
       if (url.includes('/encounter/enc-1')) {
         return Promise.resolve({
           data: { uuid: 'enc-1', encounterType: { uuid: 'type-1', display: 'Oncology Consultation' } },
@@ -42,6 +57,36 @@ describe('<Root />', () => {
     expect(screen.getByText(/enter a patient name or identifier/i)).toBeInTheDocument();
   });
 
+  it('can search by user instead', async () => {
+    renderRoot();
+
+    await userEvent.click(screen.getByRole('tab', { name: 'Users' }));
+
+    expect(screen.getByText(/enter a name or username/i)).toBeInTheDocument();
+  });
+
+  it("shows a user's modified encounters when the url names a user", async () => {
+    renderRoot('/?user=user-1');
+
+    expect(await screen.findByText('Cos John')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /back to user search/i })).toBeInTheDocument();
+  });
+
+  it('can search by provider instead', async () => {
+    renderRoot();
+
+    await userEvent.click(screen.getByRole('tab', { name: 'Providers' }));
+
+    expect(screen.getByText(/enter a provider name or identifier/i)).toBeInTheDocument();
+  });
+
+  it("shows a provider's encounters when the url names a provider", async () => {
+    renderRoot('/?provider=prov-1');
+
+    expect(await screen.findByText('MCPRPG')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /back to provider search/i })).toBeInTheDocument();
+  });
+
   it("shows a patient's encounters when the url names a patient", async () => {
     renderRoot('/?patient=patient-1');
 

package/src/types.ts

@@ -49,6 +49,35 @@ export interface AuditPatient {
   };
 }
 
+/**
+ * A user account, as returned by the REST user search. `display` is the username (or system id),
+ * while the person's real name lives on `person`.
+ */
+export interface AuditUser {
+  uuid: string;
+  display?: string;
+  username?: string;
+  systemId?: string;
+  retired?: boolean;
+  person?: {
+    uuid?: string;
+    display?: string;
+  };
+}
+
+/** A provider, as returned by the REST provider search. */
+export interface AuditProvider {
+  uuid: string;
+  display?: string;
+  identifier?: string;
+  retired?: boolean;
+  person?: {
+    uuid?: string;
+    display?: string;
+    gender?: string;
+  };
+}
+
 export interface EncounterProvider {
   uuid: string;
   voided?: boolean;
@@ -92,6 +121,11 @@ export interface AuditObs {
   concept?: OpenmrsResourceRef & { descriptions?: Array<ConceptDescription> };
   /** Set when this obs is a member of an obs group. */
   obsGroup?: OpenmrsResourceRef;
+  /**
+   * A reference by default, but the audit endpoint is asked for the whole encounter so that the
+   * observations a user touched can be grouped into the encounters they belong to.
+   */
+  encounter?: OpenmrsResourceRef | AuditEncounter;
   /** Set when this obs replaced an earlier one, i.e. when the value was edited. */
   previousVersion?: OpenmrsResourceRef;
   auditInfo?: AuditInfo;