@openmrs/esm-form-engine-lib 2.1.0-pre.1585 → 2.1.0-pre.1597

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-form-engine-lib",
-  "version": "2.1.0-pre.1585",
+  "version": "2.1.0-pre.1597",
   "description": "React Form Engine for O3",
   "browser": "dist/openmrs-esm-form-engine-lib.js",
   "main": "src/index.ts",

package/src/adapters/obs-adapter.ts

@@ -83,7 +83,7 @@ export const ObsAdapter: FormFieldValueAdapter = {
       return null;
     }
     if (hasRendering(field, 'checkbox')) {
-      return handleMultiSelect(field, value);
+      return handleMultiSelect(field, Array.isArray(value) ? value : [value]);
     }
     if (!isEmpty(value) && hasPreviousObsValueChanged(field, value)) {
       return gracefullySetSubmission(field, editObs(field, value), undefined);

package/src/api/index.ts

@@ -1,6 +1,6 @@
 import { fhirBaseUrl, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 import { encounterRepresentation } from '../constants';
-import { type OpenmrsForm, type PatientIdentifier, type PatientProgramPayload } from '../types';
+import type { FHIRObsResource, OpenmrsForm, PatientIdentifier, PatientProgramPayload } from '../types';
 import { isUuid } from '../utils/boolean-utils';
 
 export function saveEncounter(abortController: AbortController, payload, encounterUuid?: string) {
@@ -76,15 +76,18 @@ export async function getPreviousEncounter(patientUuid: string, encounterType: s
   return null;
 }
 
-export function getLatestObs(patientUuid: string, conceptUuid: string, encounterTypeUuid?: string) {
+export async function getLatestObs(
+  patientUuid: string,
+  conceptUuid: string,
+  encounterTypeUuid?: string,
+): Promise<FHIRObsResource> {
   let params = `patient=${patientUuid}&code=${conceptUuid}${
     encounterTypeUuid ? `&encounter.type=${encounterTypeUuid}` : ''
   }`;
   // the latest obs
   params += '&_sort=-date&_count=1';
-  return openmrsFetch(`${fhirBaseUrl}/Observation?${params}`).then(({ data }) => {
-    return data.entry?.length ? data.entry[0].resource : null;
-  });
+  const { data } = await openmrsFetch(`${fhirBaseUrl}/Observation?${params}`);
+  return data.entry?.length ? data.entry[0].resource : null;
 }
 
 /**

package/src/components/renderer/field/fieldLogic.ts

@@ -64,30 +64,40 @@ function evaluateFieldDependents(field: FormField, values: any, context: FormCon
             mode: sessionMode,
             patient,
           },
-        ).then((result) => {
-          setValue(dependent.id, result);
-          // validate calculated value
-          const { errors, warnings } = validateFieldValue(dependent, result, context.formFieldValidators, {
-            formFields,
-            values,
-            expressionContext: { patient, mode: sessionMode },
+        )
+          .then((result) => {
+            setValue(dependent.id, result);
+            // validate calculated value
+            const { errors, warnings } = validateFieldValue(dependent, result, context.formFieldValidators, {
+              formFields,
+              values,
+              expressionContext: { patient, mode: sessionMode },
+            });
+            if (!dependent.meta.submission) {
+              dependent.meta.submission = {};
+            }
+            dependent.meta.submission.errors = errors;
+            dependent.meta.submission.warnings = warnings;
+            if (!errors.length) {
+              context.formFieldAdapters[dependent.type].transformFieldValue(dependent, result, context);
+            }
+            updateFormField(dependent);
+          })
+          .catch((error) => {
+            reportError(error, 'Error evaluating calculate expression');
           });
-          if (!dependent.meta.submission) {
-            dependent.meta.submission = {};
-          }
-          dependent.meta.submission.errors = errors;
-          dependent.meta.submission.warnings = warnings;
-          if (!errors.length) {
-            context.formFieldAdapters[dependent.type].transformFieldValue(dependent, result, context);
-          }
-          updateFormField(dependent);
-        }).catch((error) => {
-          reportError(error, 'Error evaluating calculate expression');
-        });
       }
       // evaluate hide
       if (dependent.hide) {
-        evaluateHide({ value: dependent, type: 'field' }, formFields, values, sessionMode, patient, evaluateExpression);
+        evaluateHide(
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          sessionMode,
+          patient,
+          evaluateExpression,
+          updateFormField,
+        );
       }
       // evaluate disabled
       if (typeof dependent.disabled === 'object' && dependent.disabled.disableWhenExpression) {
@@ -197,12 +207,8 @@ function evaluateFieldDependents(field: FormField, values: any, context: FormCon
             sessionMode,
             patient,
             evaluateExpression,
+            updateFormField,
           );
-          if (isTrue(section.isHidden)) {
-            section.questions.forEach((field) => {
-              field.isParentHidden = true;
-            });
-          }
           shouldUpdateForm = true;
           break;
         }
@@ -214,14 +220,15 @@ function evaluateFieldDependents(field: FormField, values: any, context: FormCon
   if (field.pageDependents) {
     field.pageDependents?.forEach((dep) => {
       const dependent = formJson.pages.find((f) => f.label == dep);
-      evaluateHide({ value: dependent, type: 'page' }, formFields, values, sessionMode, patient, evaluateExpression);
-      if (isTrue(dependent.isHidden)) {
-        dependent.sections.forEach((section) => {
-          section.questions.forEach((field) => {
-            field.isParentHidden = true;
-          });
-        });
-      }
+      evaluateHide(
+        { value: dependent, type: 'page' },
+        formFields,
+        values,
+        sessionMode,
+        patient,
+        evaluateExpression,
+        updateFormField,
+      );
       shouldUpdateForm = true;
     });
   }

package/src/hooks/useEvaluateFormFieldExpressions.ts

@@ -109,7 +109,15 @@ export const useEvaluateFormFieldExpressions = (
   useEffect(() => {
     factoryContext.formJson?.pages?.forEach((page) => {
       if (page.hide) {
-        evaluateHide({ value: page, type: 'page' }, formFields, formValues, sessionMode, patient, evaluateExpression);
+        evaluateHide(
+          { value: page, type: 'page' },
+          formFields,
+          formValues,
+          sessionMode,
+          patient,
+          evaluateExpression,
+          null,
+        );
       } else {
         page.isHidden = false;
       }
@@ -122,6 +130,7 @@ export const useEvaluateFormFieldExpressions = (
             sessionMode,
             patient,
             evaluateExpression,
+            null,
           );
         } else {
           section.isHidden = false;

package/src/types/domain.ts

@@ -15,20 +15,80 @@ export interface OpenmrsEncounter {
 }
 
 export interface OpenmrsObs extends OpenmrsResource {
-  concept: any;
-  obsDatetime: string | Date;
-  obsGroup: OpenmrsObs;
-  groupMembers: Array<OpenmrsObs>;
-  comment: string;
-  location: OpenmrsResource;
-  order: OpenmrsResource;
-  encounter: OpenmrsResource;
-  voided: boolean;
-  value: any;
-  formFieldPath: string;
-  formFieldNamespace: string;
-  status: string;
-  interpretation: string;
+  concept?: any;
+  obsDatetime?: string | Date;
+  obsGroup?: OpenmrsObs;
+  groupMembers?: Array<OpenmrsObs>;
+  comment?: string;
+  location?: OpenmrsResource;
+  order?: OpenmrsResource;
+  encounter?: OpenmrsResource;
+  voided?: boolean;
+  value?: any;
+  formFieldPath?: string;
+  formFieldNamespace?: string;
+  status?: string;
+  interpretation?: string;
+}
+
+export interface FHIRObsResource {
+  resourceType: string;
+  id: string;
+  category: Array<{
+    coding: Array<{
+      system: string;
+      code: string;
+      display: string;
+    }>;
+  }>;
+  code: {
+    coding: Array<{
+      code: string;
+      display: string;
+    }>;
+    text: string;
+  };
+  encounter?: {
+    reference: string;
+    type: string;
+  };
+  effectiveDateTime: string;
+  issued: string;
+  valueBoolean?: boolean;
+  valueString?: string;
+  valueDateTime?: string;
+  valueQuantity?: {
+    value: number;
+    unit: string;
+    system: string;
+    code: string;
+  };
+  valueCodeableConcept?: {
+    coding: [
+      {
+        code: string;
+        display: string;
+      },
+    ];
+    text: string;
+  };
+  referenceRange: Array<{
+    low?: {
+      value: number;
+    };
+    high?: {
+      value: number;
+    };
+    type: {
+      coding: Array<{
+        system: string;
+        code: string;
+      }>;
+    };
+  }>;
+  hasMember?: Array<{
+    reference: string;
+  }>;
 }
 
 export interface OpenmrsForm {

package/src/utils/form-helper.test.ts

@@ -1,14 +1,12 @@
 import {
   findConceptByReference,
-  evaluateConditionalAnswered,
   evaluateFieldReadonlyProp,
   evaluateDisabled,
   isPageContentVisible,
+  extractObsValueAndDisplay,
 } from './form-helper';
-import { DefaultValueValidator } from '../validators/default-value-validator';
-import { type LayoutType } from '@openmrs/esm-framework';
 import { ConceptTrue } from '../constants';
-import { type FormPage, type FormField, type OpenmrsEncounter, type SessionMode } from '../types';
+import type { FormPage, FormField } from '../types';
 
 jest.mock('../validators/default-value-validator');
 
@@ -507,4 +505,160 @@ describe('Form Engine Helper', () => {
       expect(isPageContentVisible(page)).toBe(false);
     });
   });
+
+  describe('extractObsValueAndDisplay', () => {
+    // Mock form field types
+    const mockFormFields = {
+      codedField: {
+        questionOptions: {
+          rendering: 'select',
+          answers: [{ concept: '2395de62-f5a6-49b6-ab0f-57a21a9029c1', label: 'Sneezing Symptom' }],
+        },
+      },
+      toggleField: {
+        questionOptions: {
+          rendering: 'toggle',
+          answers: [],
+        },
+      },
+      dateField: {
+        questionOptions: {
+          rendering: 'date',
+        },
+      },
+      stringField: {
+        questionOptions: {
+          rendering: 'text',
+        },
+      },
+    } as any;
+
+    // Primitive value tests
+    describe('Primitive Value Handling', () => {
+      it('should handle string primitive value', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.stringField, 'Hello World');
+        expect(result).toEqual({
+          value: 'Hello World',
+          display: 'Hello World',
+        });
+      });
+
+      it('should handle number primitive value', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.stringField, 42);
+        expect(result).toEqual({
+          value: 42,
+          display: 42,
+        });
+      });
+    });
+
+    // FHIR Observation tests
+    describe('FHIR Observation Handling', () => {
+      const codedFHIRObs = {
+        resourceType: 'Observation',
+        code: {
+          coding: {
+            code: '1095de62-b5a6-49v6-ab0f-57a21a9029cb',
+          },
+        },
+        valueCodeableConcept: {
+          coding: [
+            {
+              code: '2395de62-f5a6-49b6-ab0f-57a21a9029c1',
+              display: 'Sneezing',
+            },
+          ],
+        },
+      };
+
+      const booleanFHIRObs = {
+        resourceType: 'Observation',
+        code: {
+          coding: {
+            code: 'b095deb2-b5a6-49v6-ab0f-57a21a9029cx',
+          },
+        },
+        valueBoolean: true,
+      };
+
+      const dateFHIRObs = {
+        resourceType: 'Observation',
+        code: {
+          coding: {
+            code: 'e095de62-b5a6-49v6-ab0f-57a21a9029cy',
+          },
+        },
+        valueDateTime: '2024-07-31T01:33:19+00:00',
+      };
+
+      it('should handle coded FHIR observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.codedField, codedFHIRObs);
+        expect(result).toEqual({
+          value: '2395de62-f5a6-49b6-ab0f-57a21a9029c1',
+          display: 'Sneezing Symptom',
+        });
+      });
+
+      it('should handle boolean FHIR observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.toggleField, booleanFHIRObs);
+        expect(result).toEqual({
+          value: ConceptTrue,
+          display: undefined,
+        });
+      });
+
+      it('should handle date FHIR observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.dateField, dateFHIRObs);
+        expect(result).toEqual({
+          value: expect.any(Date),
+          display: expect.stringContaining('2024-07-31'),
+        });
+      });
+    });
+
+    // OpenMRS Observation tests
+    describe('OpenMRS Observation Handling', () => {
+      const codedOpenMRSObs = {
+        value: {
+          uuid: '2395de62-f5a6-49b6-ab0f-57a21a9029c1',
+          name: { name: 'Sneezing' },
+        },
+      };
+
+      const booleanOpenMRSObs = {
+        value: {
+          uuid: 'cf82933b-3f3f-45e7-a5ab-5d31aaee3da3',
+          name: { name: 'True' },
+        },
+      };
+
+      const dateOpenMRSObs = {
+        value: '2024-07-31T01:33:19+00:00',
+      };
+
+      it('should handle coded OpenMRS observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.codedField, codedOpenMRSObs);
+        expect(result).toEqual({
+          value: '2395de62-f5a6-49b6-ab0f-57a21a9029c1',
+          display: 'Sneezing Symptom',
+        });
+      });
+
+      it('should handle boolean OpenMRS observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.toggleField, booleanOpenMRSObs);
+        expect(result).toEqual({
+          value: 'cf82933b-3f3f-45e7-a5ab-5d31aaee3da3',
+          display: 'True',
+        });
+      });
+
+      it('should handle date OpenMRS observation', () => {
+        const result = extractObsValueAndDisplay(mockFormFields.dateField, dateOpenMRSObs);
+        expect(result).toEqual({
+          value: expect.any(Date),
+          display: expect.stringMatching(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/),
+        });
+      });
+    });
+  });
 });

package/src/utils/form-helper.ts

@@ -1,8 +1,9 @@
 import { type LayoutType } from '@openmrs/esm-framework';
-import { type OpenmrsObs, type FormField, type FormPage, type FormSection, type SessionMode } from '../types';
+import type { FormField, FormPage, FormSection, SessionMode, FHIRObsResource, RenderType } from '../types';
 import { isEmpty } from '../validators/form-validator';
 import { parseToLocalDateTime } from './common-utils';
 import dayjs from 'dayjs';
+import { ConceptFalse, ConceptTrue } from '../constants';
 
 export function shouldUseInlineLayout(
   renderingType: 'single-line' | 'multiline' | 'automatic',
@@ -94,6 +95,7 @@ export function evaluateHide(
   sessionMode: SessionMode,
   patient: fhir.Patient,
   expressionRunnerFn,
+  updateFormFieldFn: (field: FormField) => void | null,
 ) {
   const { value, type } = node;
   const isHidden = expressionRunnerFn(value['hide']?.hideWhenExpression, node, allFields, allValues, {
@@ -110,15 +112,20 @@ export function evaluateHide(
   if (type == 'page') {
     value['sections'].forEach((section) => {
       section.isParentHidden = isHidden;
-      cascadeVisibilityToChildFields(isHidden, section, allFields);
+      cascadeVisibilityToChildFields(isHidden, section, allFields, updateFormFieldFn);
     });
   }
   if (type == 'section') {
-    cascadeVisibilityToChildFields(isHidden, value, allFields);
+    cascadeVisibilityToChildFields(isHidden, value, allFields, updateFormFieldFn);
   }
 }
 
-function cascadeVisibilityToChildFields(visibility: boolean, section: FormSection, allFields: Array<FormField>) {
+function cascadeVisibilityToChildFields(
+  visibility: boolean,
+  section: FormSection,
+  allFields: Array<FormField>,
+  updateFormFieldFn: (field: FormField) => void,
+) {
   const candidateIds = section.questions.map((q) => q.id);
   allFields
     .filter((field) => candidateIds.includes(field.id))
@@ -129,6 +136,7 @@ function cascadeVisibilityToChildFields(visibility: boolean, section: FormSectio
           member.isParentHidden = visibility;
         });
       }
+      updateFormFieldFn?.(field);
     });
 }
 
@@ -172,24 +180,30 @@ export function scrollIntoView(viewId: string, shouldFocus: boolean = false) {
   }
 }
 
-export const extractObsValueAndDisplay = (field: FormField, obs: OpenmrsObs) => {
+export const extractObsValueAndDisplay = (field: FormField, obs: any) => {
   const rendering = field.questionOptions.rendering;
-
-  if (typeof obs.value === 'string' || typeof obs.value === 'number') {
+  if (typeof obs !== 'object') {
+    return { value: obs, display: obs };
+  }
+  const omrsObs = obs.resourceType === 'Observation' ? mapFHIRObsToOpenMRS(obs, rendering) : obs;
+  if (!omrsObs) {
+    return { value: null, display: null };
+  }
+  if (typeof omrsObs.value === 'string' || typeof omrsObs.value === 'number') {
     if (rendering === 'date' || rendering === 'datetime') {
-      const dateObj = parseToLocalDateTime(`${obs.value}`);
+      const dateObj = parseToLocalDateTime(`${omrsObs.value}`);
       return { value: dateObj, display: dayjs(dateObj).format('YYYY-MM-DD HH:mm') };
     }
-    return { value: obs.value, display: obs.value };
+    return { value: omrsObs.value, display: omrsObs.value };
   } else if (['toggle', 'checkbox'].includes(rendering)) {
     return {
-      value: obs.value?.uuid,
-      display: obs.value?.name?.name,
+      value: omrsObs.value?.uuid,
+      display: omrsObs.value?.name?.name,
     };
   } else {
     return {
-      value: obs.value?.uuid,
-      display: field.questionOptions.answers?.find((option) => option.concept === obs.value?.uuid)?.label,
+      value: omrsObs.value?.uuid,
+      display: field.questionOptions.answers?.find((option) => option.concept === omrsObs.value?.uuid)?.label,
     };
   }
 };
@@ -212,3 +226,48 @@ export function isPageContentVisible(page: FormPage) {
     }) ?? false
   );
 }
+
+function mapFHIRObsToOpenMRS(fhirObs: FHIRObsResource, rendering: RenderType) {
+  try {
+    return {
+      obsDatetime: fhirObs.effectiveDateTime,
+      uuid: fhirObs.id,
+      concept: {
+        uuid: fhirObs.code.coding[0]?.code,
+        display: fhirObs.code.coding[0]?.display,
+      },
+      value: extractFHIRObsValue(fhirObs, rendering),
+    };
+  } catch (error) {
+    console.error('Error converting FHIR Obs to OpenMRS modelling', error);
+    return null;
+  }
+}
+
+function extractFHIRObsValue(fhirObs: FHIRObsResource, rendering: RenderType) {
+  switch (rendering) {
+    case 'toggle':
+      return fhirObs.valueBoolean ? { uuid: ConceptTrue } : { uuid: ConceptFalse };
+
+    case 'date':
+    case 'datetime':
+      return fhirObs.valueDateTime;
+
+    case 'number':
+      return fhirObs.valueQuantity?.value ?? null;
+
+    case 'radio':
+    case 'checkbox':
+    case 'select':
+    case 'content-switcher':
+      return fhirObs.valueCodeableConcept?.coding[0]
+        ? {
+            uuid: fhirObs.valueCodeableConcept?.coding[0].code,
+            name: { name: fhirObs.valueCodeableConcept?.coding[0].display },
+          }
+        : null;
+
+    default:
+      return fhirObs.valueString;
+  }
+}