@openmrs/esm-form-engine-lib 3.0.1 → 3.1.0-pre.1684

package/src/components/repeat/repeat.component.tsx

@@ -15,6 +15,7 @@ import { useFormFactory } from '../../provider/form-factory-provider';
 const renderingByTypeMap: Record<string, RenderType> = {
   obsGroup: 'group',
   testOrder: 'select',
+  diagnosis: 'ui-select-extended',
 };
 
 const Repeat: React.FC<FormFieldInputProps> = ({ field }) => {
@@ -32,6 +33,8 @@ const Repeat: React.FC<FormFieldInputProps> = ({ field }) => {
     methods: { getValues, setValue },
     addFormField,
     removeFormField,
+    deletedFields,
+    setDeletedFields,
   } = context;
 
   useEffect(() => {
@@ -113,6 +116,7 @@ const Repeat: React.FC<FormFieldInputProps> = ({ field }) => {
       clearSubmission(field);
     }
     setRows(rows.filter((q) => q.id !== field.id));
+    setDeletedFields([...deletedFields, field]);
     removeFormField(field.id);
   };
 

package/src/constants.ts

@@ -5,6 +5,7 @@ export const encounterRepresentation =
   'custom:(uuid,encounterDatetime,encounterType:(uuid,name,description),location:(uuid,name),' +
   'patient:(uuid,display),encounterProviders:(uuid,provider:(uuid,name),encounterRole:(uuid,name)),' +
   'orders:(uuid,display,concept:(uuid,display),voided),' +
+  'diagnoses:(uuid,certainty,condition,formFieldPath,formFieldNamespace,display,rank,voided,diagnosis:(coded:(uuid,display))),' +
   'obs:(uuid,obsDatetime,comment,voided,groupMembers,formFieldNamespace,formFieldPath,concept:(uuid,name:(uuid,name)),value:(uuid,name:(uuid,name),' +
   'names:(uuid,conceptNameType,name))))';
 export const FormsStore = 'forms-engine-store';

package/src/form-engine.test.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import dayjs from 'dayjs';
 import userEvent from '@testing-library/user-event';
-import { act, cleanup, render, screen, within } from '@testing-library/react';
+import { act, cleanup, render, screen, waitFor, within } from '@testing-library/react';
 import {
   ExtensionSlot,
   OpenmrsDatePicker,
@@ -44,9 +44,11 @@ import viralLoadStatusForm from '__mocks__/forms/rfe-forms/viral-load-status-for
 import readOnlyValidationForm from '__mocks__/forms/rfe-forms/read-only-validation-form.json';
 import jsExpressionValidationForm from '__mocks__/forms/rfe-forms/js-expression-validation-form.json';
 import hidePagesAndSectionsForm from '__mocks__/forms/rfe-forms/hide-pages-and-sections-form.json';
+import diagnosisForm from '__mocks__/forms/rfe-forms/diagnosis-test-form.json';
 
 import FormEngine from './form-engine.component';
-import { type SessionMode } from './types';
+import { type FormSchema, type OpenmrsEncounter, type SessionMode } from './types';
+import { useEncounter } from './hooks/useEncounter';
 
 const patientUUID = '8673ee4f-e2ab-4077-ba55-4980f408773e';
 const visit = mockVisit;
@@ -59,6 +61,7 @@ const mockExtensionSlot = jest.mocked(ExtensionSlot);
 const mockUsePatient = jest.mocked(usePatient);
 const mockUseSession = jest.mocked(useSession);
 const mockOpenmrsDatePicker = jest.mocked(OpenmrsDatePicker);
+const mockUseEncounter = jest.mocked(useEncounter);
 
 mockOpenmrsDatePicker.mockImplementation(({ id, labelText, value, onChange, isInvalid, invalidText }) => {
   return (
@@ -79,6 +82,48 @@ mockOpenmrsDatePicker.mockImplementation(({ id, labelText, value, onChange, isIn
 when(mockOpenmrsFetch).calledWith(formsResourcePath).mockReturnValue({ data: demoHtsOpenmrsForm });
 when(mockOpenmrsFetch).calledWith(clobDataResourcePath).mockReturnValue({ data: demoHtsForm });
 
+jest.mock('lodash-es/debounce', () => jest.fn((fn) => fn));
+
+jest.mock('lodash-es', () => ({
+  ...jest.requireActual('lodash-es'),
+  debounce: jest.fn((fn) => fn),
+}));
+
+jest.mock('./registry/registry', () => {
+  const originalModule = jest.requireActual('./registry/registry');
+  return {
+    ...originalModule,
+    getRegisteredDataSource: jest.fn().mockResolvedValue({
+      fetchData: jest.fn().mockImplementation((...args) => {
+        if (args[1].class?.length && !args[1].referencedValue?.key) {
+          // concept DS
+          return Promise.resolve([
+            {
+              uuid: 'stage-1-uuid',
+              display: 'stage 1',
+            },
+            {
+              uuid: 'stage-2-uuid',
+              display: 'stage 2',
+            },
+            {
+              uuid: 'stage-3-uuid',
+              display: 'stage 3',
+            },
+          ]);
+        }
+      }),
+      fetchSingleItem: jest.fn().mockImplementation((uuid: string) => {
+        return Promise.resolve({
+          uuid,
+          display: 'stage 1',
+        });
+      }),
+      toUuidAndDisplay: (data) => data,
+    }),
+  };
+});
+
 jest.mock('../src/api', () => {
   const originalModule = jest.requireActual('../src/api');
 
@@ -117,6 +162,16 @@ jest.mock('./hooks/useConcepts', () => ({
   }),
 }));
 
+jest.mock('./hooks/useEncounter', () => ({
+  useEncounter: jest.fn().mockImplementation((formJson: FormSchema) => {
+    return {
+      encounter: formJson.encounter ? (mockHxpEncounter as OpenmrsEncounter) : null,
+      isLoading: false,
+      error: undefined,
+    };
+  }),
+}));
+
 describe('Form engine component', () => {
   const user = userEvent.setup();
 
@@ -1047,7 +1102,118 @@ describe('Form engine component', () => {
     });
   });
 
-  function renderForm(formUUID, formJson, intent?: string, mode?: SessionMode) {
+  describe('Encounter diagnosis', () => {
+    it('should test addition of a diagnosis', async () => {
+      await act(async () => {
+        renderForm(null, diagnosisForm);
+      });
+
+      const testDiagnosis1AddButton = screen.getAllByRole('button', { name: 'Add' })[0];
+      await user.click(testDiagnosis1AddButton);
+
+      await waitFor(() => {
+        expect(screen.getAllByRole('combobox', { name: /^test diagnosis 1$/i }).length).toEqual(2);
+      });
+
+      expect(screen.getByRole('button', { name: /Remove/i })).toBeInTheDocument();
+    });
+
+    it('should render all diagnosis fields', async () => {
+      await act(async () => {
+        renderForm(null, diagnosisForm);
+      });
+      const diagnosisFields = screen.getAllByRole('combobox', { name: /test diagnosis 1|test diagnosis 2/i });
+      expect(diagnosisFields.length).toBe(2);
+    });
+
+    it('should be possible to delete cloned fields', async () => {
+      await act(async () => {
+        renderForm(null, diagnosisForm);
+      });
+
+      const testDiagnosis1AddButton = screen.getAllByRole('button', { name: 'Add' })[0];
+      await user.click(testDiagnosis1AddButton);
+
+      await waitFor(() => {
+        expect(screen.getAllByRole('combobox', { name: /^test diagnosis 1$/i }).length).toEqual(2);
+      });
+      const removeButton = screen.getByRole('button', { name: /Remove/i });
+
+      await user.click(removeButton);
+
+      expect(removeButton).not.toBeInTheDocument();
+    });
+
+    it('should save diagnosis field on form submission', async () => {
+      await act(async () => {
+        renderForm(null, diagnosisForm);
+      });
+
+      const saveEncounterMock = jest.spyOn(api, 'saveEncounter');
+      const combobox = await findSelectInput(screen, 'Test Diagnosis 1');
+      expect(combobox).toHaveAttribute('placeholder', 'Search...');
+
+      await user.click(combobox);
+      await user.type(combobox, 'stage');
+
+      expect(screen.getByText(/stage 1/)).toBeInTheDocument();
+      expect(screen.getByText(/stage 2/)).toBeInTheDocument();
+      expect(screen.getByText(/stage 3/)).toBeInTheDocument();
+
+      await user.click(screen.getByText('stage 1'));
+      await user.click(screen.getByRole('button', { name: /save/i }));
+      expect(saveEncounterMock).toHaveBeenCalledTimes(1);
+      const [_, encounter] = saveEncounterMock.mock.calls[0];
+      expect(encounter.diagnoses.length).toBe(1);
+      expect(encounter.diagnoses[0]).toEqual({
+        patient: '8673ee4f-e2ab-4077-ba55-4980f408773e',
+        condition: null,
+        diagnosis: {
+          coded: 'stage-1-uuid',
+        },
+        certainty: 'CONFIRMED',
+        rank: 1,
+        formFieldPath: `rfe-forms-diagnosis1`,
+        formFieldNamespace: 'rfe-forms',
+      });
+    });
+
+    it('should edit diagnosis field on form submission', async () => {
+      await act(async () => {
+        renderForm(null, diagnosisForm, null, 'edit', mockHxpEncounter.uuid);
+      });
+      mockUseEncounter.mockImplementation(() => ({ encounter: mockHxpEncounter, error: null, isLoading: false }));
+      const saveEncounterMock = jest.spyOn(api, 'saveEncounter');
+
+      const field1 = await findSelectInput(screen, 'Test Diagnosis 1');
+      expect(field1).toHaveValue('stage 1');
+
+      await user.click(field1);
+      await user.type(field1, 'stage');
+      expect(screen.getByText(/stage 1/)).toBeInTheDocument();
+      expect(screen.getByText(/stage 2/)).toBeInTheDocument();
+      expect(screen.getByText(/stage 3/)).toBeInTheDocument();
+      await user.click(screen.getByText(/stage 3/));
+      await user.click(screen.getByRole('button', { name: /save/i }));
+      expect(saveEncounterMock).toHaveBeenCalledTimes(1);
+      const [_, encounter] = saveEncounterMock.mock.calls[0];
+      expect(encounter.diagnoses.length).toBe(1);
+      expect(encounter.diagnoses[0]).toEqual({
+        patient: '8673ee4f-e2ab-4077-ba55-4980f408773e',
+        condition: null,
+        diagnosis: {
+          coded: 'stage-3-uuid',
+        },
+        certainty: 'CONFIRMED',
+        rank: 1,
+        formFieldPath: `rfe-forms-diagnosis1`,
+        formFieldNamespace: 'rfe-forms',
+        uuid: '95690fb4-0398-42d9-9ffc-8a134e6d829d',
+      });
+    });
+  });
+
+  function renderForm(formUUID, formJson, intent?: string, mode?: SessionMode, encounterUUID?: string) {
     render(
       <FormEngine
         formJson={formJson}
@@ -1055,6 +1221,7 @@ describe('Form engine component', () => {
         patientUUID={patientUUID}
         formSessionIntent={intent}
         visit={visit}
+        encounterUUID={encounterUUID}
         mode={mode ? mode : 'enter'}
       />,
     );

package/src/hooks/useConcepts.ts

@@ -1,6 +1,7 @@
 import { useMemo } from 'react';
 import useSWRInfinite from 'swr/infinite';
-import { type FetchResponse, type OpenmrsResource, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { type FetchResponse, openmrsFetch, type OpenmrsResource, restBaseUrl } from '@openmrs/esm-framework';
+import { useRestApiMaxResults } from './useRestApiMaxResults';
 
 type ConceptFetchResponse = FetchResponse<{ results: Array<OpenmrsResource> }>;
 
@@ -12,23 +13,21 @@ export function useConcepts(references: Set<string>): {
   isLoading: boolean;
   error: Error | undefined;
 } {
-  const chunkSize = 100;
+  const { maxResults } = useRestApiMaxResults();
   const totalCount = references.size;
-  const totalPages = Math.ceil(totalCount / chunkSize);
+  const totalPages = Math.ceil(totalCount / maxResults);
 
-  const getUrl = (index, prevPageData: ConceptFetchResponse) => {
+  const getUrl = (index: number, prevPageData: ConceptFetchResponse) => {
     if (index >= totalPages) {
       return null;
     }
 
-    if (!chunkSize) {
-      return null;
-    }
-
-    const start = index * chunkSize;
-    const end = start + chunkSize;
+    const start = index * maxResults;
+    const end = start + maxResults;
     const referenceChunk = Array.from(references).slice(start, end);
-    return `${restBaseUrl}/concept?references=${referenceChunk.join(',')}&v=${conceptRepresentation}`;
+    return `${restBaseUrl}/concept?references=${referenceChunk.join(
+      ',',
+    )}&v=${conceptRepresentation}&limit=${maxResults}`;
   };
 
   const { data, error, isLoading } = useSWRInfinite<ConceptFetchResponse, Error>(getUrl, openmrsFetch, {

package/src/hooks/useFormStateHelpers.ts

@@ -54,6 +54,10 @@ export function useFormStateHelpers(dispatch: Dispatch<Action>, formFields: Form
     dispatch({ type: 'SET_FORM_JSON', value: updateFormSectionReferences(formJson) });
   }, []);
 
+  const setDeletedFields = useCallback((fields: FormField[]) => {
+    dispatch({ type: 'SET_DELETED_FIELDS', value: fields });
+  }, []);
+
   return {
     addFormField,
     updateFormField,
@@ -63,5 +67,6 @@ export function useFormStateHelpers(dispatch: Dispatch<Action>, formFields: Form
     addInvalidField,
     removeInvalidField,
     setForm,
+    setDeletedFields,
   };
 }

package/src/hooks/usePatientPrograms.ts

@@ -1,42 +1,38 @@
+import useSWR from 'swr';
 import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
-import { useEffect, useState } from 'react';
-import { type FormSchema, type PatientProgram } from '../types';
-const customRepresentation = `custom:(uuid,display,program:(uuid,name,allWorkflows),dateEnrolled,dateCompleted,location:(uuid,display),states:(startDate,endDate,state:(uuid,name,retired,concept:(uuid),programWorkflow:(uuid)))`;
+import type { FormSchema, ProgramsFetchResponse } from '../types';
 
-export const usePatientPrograms = (patientUuid: string, formJson: FormSchema) => {
-  const [patientPrograms, setPatientPrograms] = useState<Array<PatientProgram>>([]);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState(null);
+const useActiveProgramEnrollments = (patientUuid: string) => {
+  const customRepresentation = `custom:(uuid,display,program:(uuid,name,allWorkflows),dateEnrolled,dateCompleted,location:(uuid,display),states:(startDate,endDate,state:(uuid,name,retired,concept:(uuid),programWorkflow:(uuid)))`;
+  const apiUrl = `${restBaseUrl}/programenrollment?patient=${patientUuid}&v=${customRepresentation}`;
 
-  useEffect(() => {
-    const abortController = new AbortController();
+  const { data, error, isLoading } = useSWR<{ data: ProgramsFetchResponse }, Error>(
+    patientUuid ? apiUrl : null,
+    openmrsFetch,
+  );
 
-    if (formJson.meta?.programs?.hasProgramFields) {
-      openmrsFetch(`${restBaseUrl}/programenrollment?patient=${patientUuid}&v=${customRepresentation}`, {
-        signal: abortController.signal,
-      })
-        .then((response) => {
-          setPatientPrograms(response.data.results.filter((enrollment) => enrollment.dateCompleted === null));
-          setIsLoading(false);
-        })
-        .catch((error) => {
-          if (error.name !== 'AbortError') {
-            setError(error);
-            setIsLoading(false);
-          }
-        });
-    } else {
-      setIsLoading(false);
-    }
+  const sortedEnrollments =
+    data?.data?.results.length > 0
+      ? data?.data.results.sort((a, b) => (b.dateEnrolled > a.dateEnrolled ? 1 : -1))
+      : null;
 
-    return () => {
-      abortController.abort();
-    };
-  }, [formJson]);
+  const activePrograms = sortedEnrollments?.filter((enrollment) => !enrollment.dateCompleted);
 
   return {
-    patientPrograms,
+    activePrograms,
     error,
     isLoading,
   };
 };
+
+export const usePatientPrograms = (patientUuid: string, formJson: FormSchema) => {
+  const { activePrograms, error, isLoading } = useActiveProgramEnrollments(
+    formJson.meta?.programs?.hasProgramFields ? patientUuid : null,
+  );
+
+  return {
+    patientPrograms: activePrograms,
+    errorFetchingPatientPrograms: error,
+    isLoadingPatientPrograms: isLoading,
+  };
+};

package/src/hooks/useRestApiMaxResults.ts

@@ -0,0 +1,35 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+type GlobalPropertyResponse = FetchResponse<{
+  results: Array<{ property: string; value: string }>;
+}>;
+
+const DEFAULT_CHUNK_SIZE = 100;
+
+export function useRestApiMaxResults() {
+  const { data, error, isLoading } = useSWR<GlobalPropertyResponse, Error>(
+    `${restBaseUrl}/systemsetting?q=webservices.rest.maxResultsAbsolute&v=custom:(property,value)`,
+    openmrsFetch,
+  );
+
+  const maxResults = useMemo(() => {
+    try {
+      const maxResultsValue = data?.data.results.find(
+        (prop) => prop.property === 'webservices.rest.maxResultsAbsolute',
+      )?.value;
+
+      const parsedValue = parseInt(maxResultsValue ?? '');
+      return !isNaN(parsedValue) && parsedValue > 0 ? parsedValue : DEFAULT_CHUNK_SIZE;
+    } catch {
+      return DEFAULT_CHUNK_SIZE;
+    }
+  }, [data]);
+
+  return {
+    maxResults,
+    error,
+    isLoading,
+  };
+}

package/src/processors/encounter/encounter-form-processor.ts

@@ -1,17 +1,5 @@
-import {
-  type FormField,
-  type FormPage,
-  type FormProcessorContextProps,
-  type FormSchema,
-  type FormSection,
-  type ValueAndDisplay,
-} from '../../types';
-import { usePatientPrograms } from '../../hooks/usePatientPrograms';
 import { useEffect, useState } from 'react';
-import { useEncounter } from '../../hooks/useEncounter';
-import { isEmpty } from '../../validators/form-validator';
-import { type FormContextProps } from '../../provider/form-provider';
-import { FormProcessor } from '../form-processor';
+import { type OpenmrsResource, showSnackbar, translateFrom } from '@openmrs/esm-framework';
 import {
   getMutableSessionProps,
   hydrateRepeatField,
@@ -23,23 +11,32 @@ import {
   savePatientIdentifiers,
   savePatientPrograms,
 } from './encounter-processor-helper';
-import { type OpenmrsResource, showSnackbar, translateFrom } from '@openmrs/esm-framework';
-import { moduleName } from '../../globals';
+import {
+  type FormField,
+  type FormPage,
+  type FormProcessorContextProps,
+  type FormSchema,
+  type FormSection,
+  type ValueAndDisplay,
+} from '../../types';
+import { evaluateAsyncExpression, type FormNode } from '../../utils/expression-runner';
 import { extractErrorMessagesFromResponse } from '../../utils/error-utils';
+import { extractObsValueAndDisplay } from '../../utils/form-helper';
+import { FormProcessor } from '../form-processor';
 import { getPreviousEncounter, saveEncounter } from '../../api';
-import { useEncounterRole } from '../../hooks/useEncounterRole';
-import { evaluateAsyncExpression, type FormNode } from '../../utils/expression-runner';
 import { hasRendering } from '../../utils/common-utils';
-import { extractObsValueAndDisplay } from '../../utils/form-helper';
+import { isEmpty } from '../../validators/form-validator';
+import { moduleName } from '../../globals';
+import { type FormContextProps } from '../../provider/form-provider';
+import { useEncounter } from '../../hooks/useEncounter';
+import { useEncounterRole } from '../../hooks/useEncounterRole';
+import { usePatientPrograms } from '../../hooks/usePatientPrograms';
 
 function useCustomHooks(context: Partial<FormProcessorContextProps>) {
   const [isLoading, setIsLoading] = useState(true);
   const { encounter, isLoading: isLoadingEncounter } = useEncounter(context.formJson);
   const { encounterRole, isLoading: isLoadingEncounterRole } = useEncounterRole();
-  const { isLoading: isLoadingPatientPrograms, patientPrograms } = usePatientPrograms(
-    context.patient?.id,
-    context.formJson,
-  );
+  const { isLoadingPatientPrograms, patientPrograms } = usePatientPrograms(context.patient?.id, context.formJson);
 
   useEffect(() => {
     setIsLoading(isLoadingPatientPrograms || isLoadingEncounter || isLoadingEncounterRole);
@@ -165,11 +162,21 @@ export class EncounterFormProcessor extends FormProcessor {
     // save encounter
     try {
       const { data: savedEncounter } = await saveEncounter(abortController, encounter, encounter.uuid);
-      const saveOrders = savedEncounter.orders.map((order) => order.orderNumber);
-      if (saveOrders.length) {
+      const savedOrders = savedEncounter.orders.map((order) => order.orderNumber);
+      const savedDiagnoses = savedEncounter.diagnoses.map((diagnosis) => diagnosis.display);
+      if (savedOrders.length) {
         showSnackbar({
           title: translateFn('ordersSaved', 'Order(s) saved successfully'),
-          subtitle: saveOrders.join(', '),
+          subtitle: savedOrders.join(', '),
+          kind: 'success',
+          isLowContrast: true,
+        });
+      }
+      // handle diagnoses
+      if (savedDiagnoses.length) {
+        showSnackbar({
+          title: translateFn('diagnosisSaved', 'Diagnosis(es) saved successfully'),
+          subtitle: savedDiagnoses.join(', '),
           kind: 'success',
           isLowContrast: true,
         });

package/src/processors/encounter/encounter-processor-helper.ts

@@ -17,6 +17,7 @@ import { DefaultValueValidator } from '../../validators/default-value-validator'
 import { cloneRepeatField } from '../../components/repeat/helpers';
 import { assignedOrderIds } from '../../adapters/orders-adapter';
 import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { assignedDiagnosesIds } from '../../adapters/encounter-diagnosis-adapter';
 
 export function prepareEncounter(
   context: FormContextProps,
@@ -25,10 +26,13 @@ export function prepareEncounter(
   encounterProvider: string,
   location: string,
 ) {
-  const { patient, formJson, domainObjectValue: encounter, formFields, visit } = context;
+  const { patient, formJson, domainObjectValue: encounter, formFields, visit, deletedFields } = context;
+  const allFormFields = [...formFields, ...deletedFields];
   const obsForSubmission = [];
-  prepareObs(obsForSubmission, formFields);
-  const ordersForSubmission = prepareOrders(formFields);
+  prepareObs(obsForSubmission, allFormFields);
+  const ordersForSubmission = prepareOrders(allFormFields);
+  const diagnosesForSubmission = prepareDiagnosis(allFormFields);
+
   let encounterForSubmission: OpenmrsEncounter = {};
 
   if (encounter) {
@@ -58,6 +62,7 @@ export function prepareEncounter(
     }
     encounterForSubmission.obs = obsForSubmission;
     encounterForSubmission.orders = ordersForSubmission;
+    encounterForSubmission.diagnoses = diagnosesForSubmission;
   } else {
     encounterForSubmission = {
       patient: patient.id,
@@ -76,6 +81,7 @@ export function prepareEncounter(
       },
       visit: visit?.uuid,
       orders: ordersForSubmission,
+      diagnoses: diagnosesForSubmission,
     };
   }
   return encounterForSubmission;
@@ -313,6 +319,33 @@ export async function hydrateRepeatField(
         }),
     );
   }
+
+  const unMappedDiagnoses = encounter.diagnoses.filter((diagnosis) => {
+    return (
+      !diagnosis.voided &&
+      !assignedDiagnosesIds.includes(diagnosis?.diagnosis?.coded.uuid) &&
+      diagnosis.formFieldPath.startsWith(`rfe-forms-${field.id}_`)
+    );
+  });
+
+  if (field.type === 'diagnosis') {
+    return Promise.all(
+      unMappedDiagnoses.map(async (diagnosis) => {
+        const idSuffix = parseInt(diagnosis.formFieldPath.split('_')[1]);
+        const clone = cloneRepeatField(field, diagnosis, idSuffix);
+        initialValues[clone.id] = await formFieldAdapters[field.type].getInitialValue(
+          clone,
+          { diagnoses: [diagnosis] } as any,
+          context,
+        );
+        if (!assignedDiagnosesIds.includes(diagnosis.diagnosis.coded.uuid)) {
+          assignedDiagnosesIds.push(diagnosis.diagnosis.coded.uuid);
+        }
+
+        return clone;
+      }),
+    );
+  }
   // handle obs groups
   return Promise.all(
     unMappedGroups.map(async (group) => {
@@ -331,3 +364,12 @@ export async function hydrateRepeatField(
     }),
   ).then((results) => results.flat());
 }
+
+function prepareDiagnosis(fields: FormField[]) {
+  const diagnoses = fields
+    .filter((field) => field.type === 'diagnosis' && hasSubmission(field))
+    .map((field) => field.meta.submission.newValue || field.meta.submission.voidedValue)
+    .filter((o) => o);
+
+  return diagnoses;
+}

package/src/provider/form-provider.tsx

@@ -7,6 +7,7 @@ export interface FormContextProps extends FormProcessorContextProps {
   methods: UseFormReturn<any>;
   workspaceLayout: 'minimized' | 'maximized';
   isSubmitting?: boolean;
+  deletedFields: FormField[];
   getFormField?: (field: string) => FormField;
   addFormField?: (field: FormField) => void;
   updateFormField?: (field: FormField) => void;
@@ -15,6 +16,7 @@ export interface FormContextProps extends FormProcessorContextProps {
   removeInvalidField?: (fieldId: string) => void;
   setInvalidFields?: (fields: FormField[]) => void;
   setForm?: (formJson: FormSchema) => void;
+  setDeletedFields?: (fields: FormField[]) => void;
 }
 
 export interface FormProviderProps extends FormContextProps {

package/src/registry/inbuilt-components/inbuiltFieldValueAdapters.ts

@@ -10,6 +10,7 @@ import { ObsCommentAdapter } from '../../adapters/obs-comment-adapter';
 import { OrdersAdapter } from '../../adapters/orders-adapter';
 import { PatientIdentifierAdapter } from '../../adapters/patient-identifier-adapter';
 import { ProgramStateAdapter } from '../../adapters/program-state-adapter';
+import { EncounterDiagnosisAdapter } from '../../adapters/encounter-diagnosis-adapter';
 import { type FormFieldValueAdapter } from '../../types';
 
 export const inbuiltFieldValueAdapters: RegistryItem<FormFieldValueAdapter>[] = [
@@ -61,4 +62,8 @@ export const inbuiltFieldValueAdapters: RegistryItem<FormFieldValueAdapter>[] =
     type: 'patientIdentifier',
     component: PatientIdentifierAdapter,
   },
+  {
+    type: 'diagnosis',
+    component: EncounterDiagnosisAdapter,
+  },
 ];

package/src/transformers/default-schema-transformer.ts

@@ -148,6 +148,9 @@ function transformByType(question: FormField) {
         ? 'date'
         : question.questionOptions.rendering;
       break;
+    case 'diagnosis':
+      handleDiagnosis(question);
+      break;
   }
 }
 
@@ -276,3 +279,32 @@ function handleQuestionsWithObsComments(sectionQuestions: Array<FormField>): Arr
 
   return augmentedQuestions;
 }
+
+function handleDiagnosis(question: FormField) {
+  if (
+    ('dataSource' in question.questionOptions && question.questionOptions['dataSource'] === 'diagnoses') ||
+    question.type === 'diagnosis'
+  ) {
+    question.questionOptions.datasource = {
+      name: 'problem_datasource',
+      config: {
+        class: question.questionOptions.diagnosis?.conceptClasses,
+      },
+    };
+    if (question.questionOptions.diagnosis?.conceptSet) {
+      question.questionOptions = {
+        ...question.questionOptions,
+        concept: question.questionOptions.diagnosis?.conceptSet,
+        datasource: {
+          name: 'problem_datasource',
+          config: {
+            useSetMembersByConcept: true,
+          },
+        },
+      };
+    }
+    question.questionOptions.isSearchable = true;
+
+    delete question.questionOptions['dataSource'];
+  }
+}