@openmrs/esm-fast-data-entry-app 1.4.2-pre.704 → 1.4.2-pre.707

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-fast-data-entry-app",
-  "version": "1.4.2-pre.704",
+  "version": "1.4.2-pre.707",
   "license": "MPL-2.0",
   "description": "O3 frontend module for fast data entry using the OpenMRS Angular Form Engine",
   "browser": "dist/openmrs-esm-fast-data-entry-app.js",
@@ -89,7 +89,7 @@
     "semver": "^7.5.4",
     "swr": "^2.2.4",
     "turbo": "^2.5.2",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.0"
   },
   "dependencies": {
     "dotenv": "^16.4.7",

package/src/FormBootstrap.test.tsx

@@ -0,0 +1,112 @@
+import React from 'react';
+import { act, render, screen } from '@testing-library/react';
+import { detach, ExtensionSlot } from '@openmrs/esm-framework';
+import GroupFormWorkflowContext from './context/GroupFormWorkflowContext';
+import useGetPatient from './hooks/useGetPatient';
+import FormBootstrap from './FormBootstrap';
+
+jest.mock('./hooks/useGetPatient', () => jest.fn());
+
+const mockDetach = jest.mocked(detach);
+const mockExtensionSlot = jest.mocked(ExtensionSlot);
+const mockUseGetPatient = useGetPatient as jest.MockedFunction<typeof useGetPatient>;
+
+const renderFormBootstrap = (props = {}) =>
+  render(
+    <GroupFormWorkflowContext.Provider
+      value={
+        {
+          activeSessionMeta: {
+            sessionName: 'April Session',
+            practitionerName: 'Alice',
+            sessionDate: '2026-04-15',
+            sessionNotes: 'Follow-up notes',
+          },
+        } as never
+      }
+    >
+      <FormBootstrap
+        formUuid="triage-form"
+        patientUuid="patient-1"
+        visitUuid="visit-1"
+        visitTypeUuid="visit-type-1"
+        encounterUuid="encounter-1"
+        handlePostResponse={jest.fn()}
+        handleEncounterCreate={jest.fn()}
+        handleOnValidate={jest.fn()}
+        hidePatientBanner={true}
+        {...props}
+      />
+    </GroupFormWorkflowContext.Provider>,
+  );
+
+describe('FormBootstrap', () => {
+  beforeEach(() => {
+    mockExtensionSlot.mockImplementation(() => <div data-testid="form-widget-slot" />);
+    mockUseGetPatient.mockReturnValue({
+      id: 'patient-1',
+      name: [{ given: ['Ada'], family: 'Lovelace' }],
+    } as fhir.Patient);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('passes the expected widget state once the patient is available', () => {
+    renderFormBootstrap();
+
+    expect(screen.getByTestId('form-widget-slot')).toBeInTheDocument();
+
+    const [{ name, state }] = mockExtensionSlot.mock.calls[0];
+    expect(name).toBe('form-widget-slot');
+    expect(state).toEqual(
+      expect.objectContaining({
+        view: 'form',
+        formUuid: 'triage-form',
+        visitUuid: 'visit-1',
+        visitTypeUuid: 'visit-type-1',
+        patientUuid: 'patient-1',
+        patient: expect.objectContaining({ id: 'patient-1' }),
+        encounterUuid: 'encounter-1',
+        showDiscardSubmitButtons: false,
+        hideControls: true,
+        hidePatientBanner: true,
+        preFilledQuestions: {
+          sessionName: 'April Session',
+          practitionerName: 'Alice',
+          sessionDate: '2026-04-15',
+          sessionNotes: 'Follow-up notes',
+          encDate: '2026-04-15',
+        },
+      }),
+    );
+  });
+
+  it('refreshes the widget after submit and detaches it on unmount', () => {
+    jest.useFakeTimers();
+    const handlePostResponse = jest.fn();
+    const { unmount } = renderFormBootstrap({ handlePostResponse });
+
+    const [{ state }] = mockExtensionSlot.mock.calls[0];
+    const handlePostResponseFromState = state.handlePostResponse as (encounter: { uuid: string }) => void;
+
+    act(() => {
+      handlePostResponseFromState({ uuid: 'encounter-2' });
+    });
+
+    expect(handlePostResponse).toHaveBeenCalledWith({ uuid: 'encounter-2' });
+    expect(screen.queryByTestId('form-widget-slot')).not.toBeInTheDocument();
+
+    act(() => {
+      jest.advanceTimersByTime(1);
+    });
+
+    expect(screen.getByTestId('form-widget-slot')).toBeInTheDocument();
+    expect(mockExtensionSlot).toHaveBeenCalledTimes(2);
+
+    unmount();
+
+    expect(mockDetach).toHaveBeenCalledWith('form-widget-slot', 'form-widget-slot');
+  });
+});

package/src/context/FormWorkflowReducer.test.ts

@@ -0,0 +1,142 @@
+import { navigate } from '@openmrs/esm-framework';
+import { initialWorkflowState } from './FormWorkflowContext';
+import reducer, { fdeWorkflowStorageName, fdeWorkflowStorageVersion } from './FormWorkflowReducer';
+
+const mockNavigate = jest.mocked(navigate);
+
+const buildState = (formStateOverrides = {}) => ({
+  ...initialWorkflowState,
+  activeFormUuid: 'triage-form',
+  userUuid: 'user-1',
+  forms: {
+    'triage-form': {
+      workflowState: 'NEW_PATIENT',
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      patientUuids: [],
+      encounters: {},
+      ...formStateOverrides,
+    },
+  },
+});
+
+describe('FormWorkflowReducer', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('initializes a fresh workflow state when there is no saved session', () => {
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'triage-form',
+      userUuid: 'user-1',
+    });
+
+    expect(state.activeFormUuid).toBe('triage-form');
+    expect(state.forms['triage-form']).toMatchObject({
+      workflowState: 'NEW_PATIENT',
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      patientUuids: [],
+      encounters: {},
+    });
+
+    expect(JSON.parse(localStorage.getItem(`${fdeWorkflowStorageName}:user-1`))).toMatchObject({
+      _storageVersion: fdeWorkflowStorageVersion,
+      activeFormUuid: 'triage-form',
+    });
+  });
+
+  it('restores a saved workflow and applies a patient from the URL when provided', () => {
+    localStorage.setItem(
+      `${fdeWorkflowStorageName}:user-1`,
+      JSON.stringify({
+        _storageVersion: fdeWorkflowStorageVersion,
+        activeFormUuid: 'triage-form',
+        userUuid: 'user-1',
+        forms: {
+          'triage-form': {
+            workflowState: 'REVIEW',
+            activePatientUuid: null,
+            activeEncounterUuid: null,
+            patientUuids: ['patient-a'],
+            encounters: {},
+          },
+        },
+      }),
+    );
+
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'triage-form',
+      newPatientUuid: 'patient-b',
+      userUuid: 'user-1',
+    });
+
+    expect(state.forms['triage-form']).toMatchObject({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-b',
+    });
+    expect(state.forms['triage-form'].patientUuids).toEqual(['patient-a', 'patient-b']);
+  });
+
+  it('dispatches the submit event and moves the workflow into SUBMIT_FOR_NEXT', () => {
+    const dispatchEventSpy = jest.spyOn(window, 'dispatchEvent');
+    const state = buildState({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'SUBMIT_FOR_NEXT',
+    });
+
+    expect(nextState.forms['triage-form'].workflowState).toBe('SUBMIT_FOR_NEXT');
+    expect(dispatchEventSpy).toHaveBeenCalledTimes(1);
+
+    const event = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+    expect(event.type).toBe('ampath-form-action');
+    expect(event.detail).toEqual({
+      formUuid: 'triage-form',
+      patientUuid: 'patient-a',
+      action: 'onSubmit',
+    });
+  });
+
+  it('stores the encounter and returns to NEW_PATIENT after saving for next', () => {
+    const state = buildState({
+      workflowState: 'SUBMIT_FOR_NEXT',
+      activePatientUuid: 'patient-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'SAVE_ENCOUNTER',
+      encounterUuid: 'encounter-1',
+    });
+
+    expect(nextState.forms['triage-form']).toMatchObject({
+      workflowState: 'NEW_PATIENT',
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      encounters: {
+        'patient-a': 'encounter-1',
+      },
+    });
+  });
+
+  it('destroys the active form session and navigates back to the forms page after complete', () => {
+    const state = buildState({
+      workflowState: 'SUBMIT_FOR_COMPLETE',
+      activePatientUuid: 'patient-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'SAVE_ENCOUNTER',
+      encounterUuid: 'encounter-1',
+    });
+
+    expect(nextState.activeFormUuid).toBeNull();
+    expect(nextState.forms).toEqual({});
+    expect(mockNavigate).toHaveBeenCalledWith({ to: '${openmrsSpaBase}/forms' });
+  });
+});

package/src/context/GroupFormWorkflowReducer.test.ts

@@ -0,0 +1,302 @@
+import { navigate } from '@openmrs/esm-framework';
+import { initialWorkflowState } from './GroupFormWorkflowContext';
+import reducer, { fdeGroupWorkflowStorageName, fdeGroupWorkflowStorageVersion } from './GroupFormWorkflowReducer';
+
+jest.mock('uuid', () => ({
+  v4: jest.fn(() => 'generated-session-uuid'),
+}));
+
+const mockNavigate = jest.mocked(navigate);
+
+const buildState = (formStateOverrides = {}, rootStateOverrides = {}) => ({
+  ...initialWorkflowState,
+  activeFormUuid: 'group-form',
+  userUuid: 'user-1',
+  forms: {
+    'group-form': {
+      workflowState: 'NEW_GROUP_SESSION',
+      groupUuid: null,
+      groupName: null,
+      groupMembers: [],
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+      patientUuids: [],
+      encounters: {},
+      visits: {},
+      ...formStateOverrides,
+    },
+  },
+  ...rootStateOverrides,
+});
+
+describe('GroupFormWorkflowReducer', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('initializes a fresh group workflow state when there is no saved session', () => {
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'group-form',
+      userUuid: 'user-1',
+    });
+
+    expect(state.activeFormUuid).toBe('group-form');
+    expect(state.forms['group-form']).toMatchObject({
+      workflowState: 'NEW_GROUP_SESSION',
+      groupUuid: null,
+      patientUuids: [],
+      encounters: {},
+      visits: {},
+    });
+
+    expect(JSON.parse(localStorage.getItem(`${fdeGroupWorkflowStorageName}:user-1`))).toMatchObject({
+      _storageVersion: fdeGroupWorkflowStorageVersion,
+      activeFormUuid: 'group-form',
+    });
+  });
+
+  it('restores a saved workflow and derives the current patient and visit state', () => {
+    localStorage.setItem(
+      `${fdeGroupWorkflowStorageName}:user-1`,
+      JSON.stringify({
+        _storageVersion: fdeGroupWorkflowStorageVersion,
+        activeFormUuid: 'group-form',
+        userUuid: 'user-1',
+        forms: {
+          'group-form': {
+            workflowState: 'EDIT_FORM',
+            patientUuids: ['patient-a', 'patient-b'],
+            encounters: {
+              'patient-a': 'encounter-a',
+            },
+            visits: {
+              'patient-a': 'visit-a',
+            },
+          },
+        },
+      }),
+    );
+
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'group-form',
+      userUuid: 'user-1',
+    });
+
+    expect(state.forms['group-form']).toMatchObject({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'generated-session-uuid',
+    });
+  });
+
+  it('stores the selected group and clears the active patient state', () => {
+    const state = buildState({
+      activePatientUuid: 'patient-z',
+      activeEncounterUuid: 'encounter-z',
+      activeVisitUuid: 'visit-z',
+      activeSessionUuid: 'session-z',
+    });
+
+    const nextState = reducer(state, {
+      type: 'SET_GROUP',
+      group: {
+        uuid: 'cohort-1',
+        name: 'Nutrition Cohort',
+        cohortMembers: [{ patient: { uuid: 'patient-a' } }, { patient: { uuid: 'patient-b' } }],
+      },
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      groupUuid: 'cohort-1',
+      groupName: 'Nutrition Cohort',
+      groupMembers: ['patient-a', 'patient-b'],
+      patientUuids: ['patient-a', 'patient-b'],
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+    });
+  });
+
+  it('sets session metadata and moves to the first patient in edit mode', () => {
+    const state = buildState({
+      patientUuids: ['patient-a', 'patient-b'],
+      encounters: {
+        'patient-a': 'encounter-a',
+      },
+      visits: {
+        'patient-a': 'visit-a',
+      },
+    });
+
+    const nextState = reducer(state, {
+      type: 'SET_SESSION_META',
+      meta: {
+        sessionName: 'April Session',
+        practitionerName: 'Alice',
+        sessionDate: '2026-04-15',
+        sessionNotes: 'Notes',
+      },
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      sessionMeta: {
+        sessionName: 'April Session',
+        practitionerName: 'Alice',
+        sessionDate: '2026-04-15',
+        sessionNotes: 'Notes',
+      },
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'generated-session-uuid',
+      workflowState: 'EDIT_FORM',
+    });
+  });
+
+  it('adds and removes patient UUIDs without duplicating entries', () => {
+    const state = buildState({
+      patientUuids: ['patient-a'],
+    });
+
+    const unchangedState = reducer(state, {
+      type: 'ADD_PATIENT_UUID',
+      patientUuid: 'patient-a',
+    });
+    expect(unchangedState).toBe(state);
+
+    const addedState = reducer(state, {
+      type: 'ADD_PATIENT_UUID',
+      patientUuid: 'patient-b',
+    });
+    expect(addedState.forms['group-form'].patientUuids).toEqual(['patient-a', 'patient-b']);
+
+    const removedState = reducer(addedState, {
+      type: 'REMOVE_PATIENT_UUID',
+      patientUuid: 'patient-a',
+    });
+    expect(removedState.forms['group-form'].patientUuids).toEqual(['patient-b']);
+  });
+
+  it('dispatches validate events and stores the visit UUID for the active patient', () => {
+    const dispatchEventSpy = jest.spyOn(window, 'dispatchEvent');
+    const state = buildState({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+    });
+
+    const validatingState = reducer(state, {
+      type: 'VALIDATE_FOR_NEXT',
+    });
+
+    expect(validatingState.forms['group-form'].workflowState).toBe('VALIDATE_FOR_NEXT');
+    const event = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+    expect(event.detail).toEqual({
+      formUuid: 'group-form',
+      patientUuid: 'patient-a',
+      action: 'validateForm',
+    });
+
+    const visitState = reducer(state, {
+      type: 'UPDATE_VISIT_UUID',
+      visitUuid: 'visit-a',
+    });
+
+    expect(visitState.forms['group-form']).toMatchObject({
+      activeVisitUuid: 'visit-a',
+      visits: {
+        'patient-a': 'visit-a',
+      },
+    });
+  });
+
+  it('submits for next and advances to the requested patient after saving', () => {
+    const dispatchEventSpy = jest.spyOn(window, 'dispatchEvent');
+    const state = buildState(
+      {
+        workflowState: 'EDIT_FORM',
+        activePatientUuid: 'patient-a',
+        patientUuids: ['patient-a', 'patient-b', 'patient-c'],
+        visits: {
+          'patient-c': 'visit-c',
+        },
+      },
+      {
+        nextPatientUuid: null,
+      },
+    );
+
+    const submittingState = reducer(state, {
+      type: 'SUBMIT_FOR_NEXT',
+      nextPatientUuid: 'patient-c',
+    });
+
+    expect(submittingState.forms['group-form'].workflowState).toBe('SUBMIT_FOR_NEXT');
+    expect(submittingState.nextPatientUuid).toBe('patient-c');
+    const submitEvent = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+    expect(submitEvent.detail).toEqual({
+      formUuid: 'group-form',
+      patientUuid: 'patient-a',
+      action: 'onSubmit',
+    });
+
+    const savedState = reducer(submittingState, {
+      type: 'SAVE_ENCOUNTER',
+      encounterUuid: 'encounter-a',
+    });
+
+    expect(savedState.forms['group-form']).toMatchObject({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-c',
+      activeEncounterUuid: null,
+      activeVisitUuid: 'visit-c',
+      encounters: {
+        'patient-a': 'encounter-a',
+      },
+    });
+  });
+
+  it('clears the active session pointers when going to review', () => {
+    const state = buildState({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'session-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'GO_TO_REVIEW',
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      workflowState: 'REVIEW',
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+    });
+  });
+
+  it('destroys the active group session and navigates back to forms', () => {
+    const state = buildState({
+      workflowState: 'SUBMIT_FOR_COMPLETE',
+      activePatientUuid: 'patient-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'DESTROY_SESSION',
+    });
+
+    expect(nextState.activeFormUuid).toBeNull();
+    expect(nextState.forms).toEqual({});
+    expect(nextState.formDestroyed).toBe(true);
+    expect(mockNavigate).toHaveBeenCalledWith({ to: '${openmrsSpaBase}/forms' });
+  });
+});

package/src/context/GroupFormWorkflowReducer.ts

@@ -365,7 +365,7 @@ const reducer = (state, action) => {
           [state.activeFormUuid]: {
             ...state.forms[state.activeFormUuid],
             activeEncounterUuid: null,
-            activVisitUuid: null,
+            activeVisitUuid: null,
             activePatientUuid: null,
             activeSessionUuid: null,
             workflowState: 'REVIEW',

package/src/declarations.d.ts

@@ -1,3 +1,2 @@
 declare module '*.css';
 declare module '*.scss';
-declare type SideNavProps = object;