Fix issue with non-enumerable props in calculated expressions

Author: ruscoder

src/components.tsx

@@ -12,6 +12,7 @@ import {
     evaluateQuestionItemExpression,
     getBranchItems,
     getEnabledQuestions,
+    stripNonEnumerable,
     wrapAnswerValue,
 } from './utils.js';
 
@@ -73,12 +74,16 @@ export function QuestionItem(props: QuestionItemProps) {
     useEffect(() => {
         // TODO: think about use cases for group context
         if (itemContext && calculatedExpression) {
+            // Fhirpath returns result with non-enumerable properties such as __path__
+            // It's cleaned up here because it's not part of actual value
+            // And it might invoke endless recursion because
+            // we rely on fact of equality of prev and current values
             const newValues = evaluateQuestionItemExpression(
                 linkId,
                 'calculatedExpression',
                 itemContext,
                 calculatedExpression,
-            );
+            ).map(stripNonEnumerable);
 
             const newAnswers: FormAnswerItems[] | undefined = newValues.length
                 ? repeats

src/utils.ts

@@ -837,6 +837,18 @@ export function evaluateQuestionItemExpression(
     }
 }
 
+export function stripNonEnumerable<T>(obj: T): T {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+
+    if (Array.isArray(obj)) {
+        return [...obj] as unknown as T;
+    }
+
+    return { ...obj };
+}
+
 export function getChoiceTypeValue(obj: Record<any, any>, prefix: string): any | undefined {
     const prefixKey = Object.keys(obj).filter((key: string) => key.startsWith(prefix))[0];
 

tests/utils.test.ts

@@ -21,6 +21,7 @@ import {
     evaluateQuestionItemExpression,
     findAnswersForQuestion,
     ITEM_KEY,
+    stripNonEnumerable,
 } from '../src/utils';
 import {
     ParametersParameter,
@@ -2833,3 +2834,51 @@ describe('findAnswersForQuestion', () => {
         );
     });
 });
+
+describe('stripNonEnumerable', () => {
+    test('works correctly for array without non-enums', () => {
+        expect(stripNonEnumerable([1, null, undefined])).toStrictEqual([1, null, undefined]);
+    });
+
+    test('works correctly for array with non-enums', () => {
+        const arrWithNonEnum = [1, 2, 3];
+        Object.defineProperty(arrWithNonEnum, '__path__', {
+            value: 'non-enum-prop',
+            enumerable: false,
+        });
+        expect(stripNonEnumerable(arrWithNonEnum)).toStrictEqual([1, 2, 3]);
+    });
+
+    test('works correctly for object without non-enums', () => {
+        expect(stripNonEnumerable({ a: 1, b: null, c: undefined })).toStrictEqual({ a: 1, b: null, c: undefined });
+    });
+
+    test('works correctly for object with non-enums', () => {
+        const objWithNonEnum = { a: 1, b: 2, c: 3 };
+        Object.defineProperty(objWithNonEnum, '__path__', {
+            value: 'non-enum-prop',
+            enumerable: false,
+        });
+        expect(stripNonEnumerable(objWithNonEnum)).toStrictEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('works correctly for null', () => {
+        expect(stripNonEnumerable(null)).toStrictEqual(null);
+    });
+
+    test('works correctly for undefined', () => {
+        expect(stripNonEnumerable(undefined)).toStrictEqual(undefined);
+    });
+
+    test('works correctly for string', () => {
+        expect(stripNonEnumerable('string')).toStrictEqual('string');
+    });
+
+    test('works correctly for number', () => {
+        expect(stripNonEnumerable(1)).toStrictEqual(1);
+    });
+
+    test('works correctly for boolean', () => {
+        expect(stripNonEnumerable(true)).toStrictEqual(true);
+    });
+});