sdc-qrf 1.0.0-beta.2 → 1.0.0-beta.21

package/src/fce.types.ts

@@ -9,6 +9,7 @@ import {
     Questionnaire,
     QuestionnaireItem,
     Reference,
+    QuestionnaireItemAnswerOption,
 } from 'fhir/r4b';
 
 export interface FCEQuestionnaire extends Questionnaire {
@@ -59,6 +60,9 @@ export interface FCEQuestionnaireItem extends QuestionnaireItem {
     /** NOTE: from extension http://hl7.org/fhir/StructureDefinition/questionnaire-constraint */
     /** An invariant that must be satisfied before responses to the questionnaire can be considered "complete". */
     itemConstraint?: FCEQuestionnaireItemConstraint[];
+    /** NOTE: from extension http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-answerOptionsToggleExpression */
+    /** A complex expression that provides a list of the allowed options that should be enabled or disabled based on the evaluation of a provided expression. */
+    answerOptionsToggleExpression?: FCEQuestionnaireItemAnswerOptionsToggleExpression[];
     /** NOTE: from extension http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-enableWhenExpression */
     /** An expression that returns a boolean value for whether to enable the item. */
     enableWhenExpression?: Expression;
@@ -103,6 +107,7 @@ export interface FCEQuestionnaireItem extends QuestionnaireItem {
     helpText?: string;
     stopLabel?: string;
     rowsNumber?: number;
+    colsNumber?: number;
     unitOption?: Coding[];
     columnSize?: number;
     itemMedia?: Attachment;
@@ -113,6 +118,8 @@ export interface FCEQuestionnaireItem extends QuestionnaireItem {
     maxValue?: Extension;
     minQuantity?: Extension;
     maxQuantity?: Extension;
+    minOccurs?: number;
+    maxOccurs?: number;
     showOrdinalValue?: boolean;
     preferredTerminologyServer?: string;
     openLabel?: string;
@@ -121,6 +128,7 @@ export interface FCEQuestionnaireItem extends QuestionnaireItem {
     choiceOrientation?: 'horizontal' | 'vertical';
     choiceColumns?: number;
     ordinalValue?: number;
+    mimeType?: string[];
 }
 
 export interface FCEQuestionnaireItemText {
@@ -169,6 +177,16 @@ export interface FCEQuestionnaireItemConstraint {
     severity: string;
 }
 
+export type FCEQuestionnaireItemAnswerOptionsToggleExpressionOption = Omit<
+    QuestionnaireItemAnswerOption,
+    'initialSelected' | '_initialSelected'
+>;
+
+export interface FCEQuestionnaireItemAnswerOptionsToggleExpression {
+    expression: Expression;
+    option: Array<FCEQuestionnaireItemAnswerOptionsToggleExpressionOption>;
+}
+
 export interface FCEQuestionnaireLaunchContext {
     /** NOTE: from extension description */
     description?: string;

package/src/index.ts

@@ -2,13 +2,17 @@ export * from './types';
 export {
     mapFormToResponse,
     mapResponseToForm,
-    findAnswersForQuestionsRecursive,
     removeDisabledAnswers,
     getEnabledQuestions,
     calcInitialContext,
     parseFhirQueryExpression,
+    findAnswersForQuestion,
     getChecker,
+    cleanFormAnswerItems,
     toAnswerValue,
+    getAnswerValues,
+    getAnswerValueType,
+    isAnswerValueEmpty,
     populateItemKey,
     removeItemKey,
     getItemKey,

package/src/types.ts

@@ -109,7 +109,8 @@ export interface FormAnswerItems {
     items?: FormItems;
 }
 
-export type FormItems = Record<string, FormGroupItems | FormAnswerItems[] | undefined>;
+// Form renderers might insert undefined for missing field values even into array
+export type FormItems = Record<string, FormGroupItems | (FormAnswerItems | undefined)[] | undefined>;
 
 export interface QuestionnaireResponseFormData {
     formValues: FormItems;

package/src/utils.ts

@@ -10,7 +10,9 @@ import {
     Expression,
     Questionnaire,
     QuestionnaireItem,
+    QuestionnaireItemAnswerOption,
     QuestionnaireItemEnableWhen,
+    QuestionnaireItemInitial,
     QuestionnaireResponse,
     QuestionnaireResponseItem,
     QuestionnaireResponseItemAnswer,
@@ -193,7 +195,7 @@ function isGroup(question: QuestionnaireItem) {
 
 function isFormGroupItems(
     question: QuestionnaireItem,
-    answers: FormGroupItems | FormAnswerItems[],
+    answers: FormGroupItems | (FormAnswerItems | undefined)[],
 ): answers is FormGroupItems {
     return isGroup(question) && _.isPlainObject(answers);
 }
@@ -249,25 +251,29 @@ function mapFormToResponseRecursive(
             }, acc);
         }
 
+        const qrItemAnswers = cleanFormAnswerItems(answers).reduce((answersAcc, answer) => {
+            const items = hasSubAnswerItems(answer.items)
+                ? mapFormToResponseRecursive(answer.items, question.item ?? [])
+                : [];
+
+            return [
+                ...answersAcc,
+                {
+                    ...toFHIRAnswerValue(answer.value!, 'value'),
+                    ...(items.length ? { item: items } : {}),
+                },
+            ];
+        }, [] as QuestionnaireResponseItemAnswer[]);
+
+        if (!qrItemAnswers.length) {
+            return acc;
+        }
+
         return [
             ...acc,
             {
                 linkId,
-                answer: answers
-                    .filter((answer) => !isAnswerValueEmpty(answer.value))
-                    .reduce((answersAcc, answer) => {
-                        const items = hasSubAnswerItems(answer.items)
-                            ? mapFormToResponseRecursive(answer.items, question.item ?? [])
-                            : [];
-
-                        return [
-                            ...answersAcc,
-                            {
-                                ...toFHIRAnswerValue(answer.value!, 'value'),
-                                ...(items.length ? { item: items } : {}),
-                            },
-                        ];
-                    }, [] as QuestionnaireResponseItemAnswer[]),
+                answer: qrItemAnswers,
             },
         ];
     }, [] as QuestionnaireResponseItem[]);
@@ -282,7 +288,7 @@ export function mapFormToResponse(
     };
 }
 
-const ITEM_KEY = '_itemKey';
+export const ITEM_KEY = '_itemKey';
 export function getItemKey(items: FormGroupItems | FormAnswerItems) {
     return (items as any)[ITEM_KEY];
 }
@@ -380,7 +386,9 @@ export function mapResponseToForm(resource: QuestionnaireResponse, questionnaire
     return mapResponseToFormRecursive(resource.item ?? [], questionnaire.item ?? []);
 }
 
-export function findAnswersForQuestionsRecursive(linkId: string, values?: FormItems): any | null {
+function findAnswersForQuestionsRecursive(linkId: string, values?: FormItems): any | null {
+    // TODO: specify types for returning value
+    // TODO: pass Questionnaire structure to make code robust
     if (values && _.has(values, linkId)) {
         return values[linkId];
     }
@@ -404,7 +412,7 @@ export function findAnswersForQuestionsRecursive(linkId: string, values?: FormIt
                             return acc2;
                         }
 
-                        return findAnswersForQuestionsRecursive(linkId, v2.items);
+                        return findAnswersForQuestionsRecursive(linkId, v2?.items);
                     },
                     null,
                 );
@@ -428,7 +436,13 @@ export function findAnswersForQuestionsRecursive(linkId: string, values?: FormIt
     );
 }
 
-function findAnswersForQuestion(linkId: string, parentPath: string[], values: FormItems): Array<FormAnswerItems> {
+// TODO: deprecate usage of this function because it relies on internals
+// TODO: pass Questionnaire structure to make code robust, currently it uses isNaN that might work falsy when linkId is number
+export function findAnswersForQuestion(linkId: string, parentPath: string[], values: FormItems): FormAnswerItems[] {
+    if (linkId === ITEM_KEY) {
+        return [];
+    }
+
     const p = _.cloneDeep(parentPath);
 
     // Go up
@@ -437,11 +451,13 @@ function findAnswersForQuestion(linkId: string, parentPath: string[], values: Fo
 
         // Find answers in parent groups (including repeatable)
         // They might have either 'items' of the group or number of the repeatable group in path
+        // TODO: using isNaN might return invalid value for linkId like '0'
         if (part === 'items' || !isNaN(part as any)) {
+            // TODO: specify type FormItems, and handle group's linkId
             const parentGroup = _.get(values, [...p, part]);
 
             if (typeof parentGroup === 'object' && linkId in parentGroup) {
-                return parentGroup[linkId];
+                return cleanFormAnswerItems(parentGroup[linkId]);
             }
         }
     }
@@ -449,7 +465,7 @@ function findAnswersForQuestion(linkId: string, parentPath: string[], values: Fo
     // Go down
     const answers = findAnswersForQuestionsRecursive(linkId, values);
 
-    return answers ? answers : [];
+    return answers ? cleanFormAnswerItems(answers) : [];
 }
 
 export function compareValue(firstAnswerValue: AnswerValue, secondAnswerValue: AnswerValue) {
@@ -457,7 +473,9 @@ export function compareValue(firstAnswerValue: AnswerValue, secondAnswerValue: A
     const secondValueType = getAnswerValueType(secondAnswerValue);
 
     if (firstValueType !== secondValueType) {
-        throw new Error('Enable when must be used for the same type');
+        throw new Error(
+            `Enable when must be used for the same type, first type is ${firstValueType}, second type is ${secondValueType}`,
+        );
     }
     if (!_.includes(FHIRPrimitiveTypes, firstValueType)) {
         throw new Error('Impossible to compare non-primitive type');
@@ -482,7 +500,9 @@ export function isValueEqual(firstValue: AnswerValue, secondValue: AnswerValue)
     const secondValueType = getAnswerValueType(secondValue);
 
     if (firstValueType !== secondValueType) {
-        console.error('Enable when must be used for the same type');
+        console.error(
+            `Enable when must be used for the same type, first type is ${firstValueType}, second type is ${secondValueType}`,
+        );
 
         return false;
     }
@@ -686,21 +706,19 @@ function removeDisabledAnswersRecursive(args: RemoveDisabledAnswersRecursiveArgs
 
         return {
             ...acc,
-            [linkId!]: answers
-                .filter((answer) => !isAnswerValueEmpty(answer.value))
-                .reduce((answersAcc, answer, index) => {
-                    const items = hasSubAnswerItems(answer.items)
-                        ? removeDisabledAnswersRecursive({
-                              questionnaireItems: questionnaireItem.item ?? [],
-                              parentPath: [...args.parentPath, linkId!, index.toString(), 'items'],
-                              answersItems: answer.items,
-                              initialValues: { ...values, [linkId!]: [...answersAcc, { ...answer, items: [] }] },
-                              context: args.context,
-                          })
-                        : {};
-
-                    return [...answersAcc, { ...answer, items }];
-                }, [] as any),
+            [linkId!]: cleanFormAnswerItems(answers).reduce((answersAcc, answer, index) => {
+                const items = hasSubAnswerItems(answer.items)
+                    ? removeDisabledAnswersRecursive({
+                          questionnaireItems: questionnaireItem.item ?? [],
+                          parentPath: [...args.parentPath, linkId!, index.toString(), 'items'],
+                          answersItems: answer.items,
+                          initialValues: { ...values, [linkId!]: [...answersAcc, { ...answer, items: [] }] },
+                          context: args.context,
+                      })
+                    : {};
+
+                return [...answersAcc, { ...answer, items }];
+            }, [] as any),
         };
     }, {} as any);
 }
@@ -825,9 +843,21 @@ export function getChoiceTypeValue(obj: Record<any, any>, prefix: string): any |
     return prefixKey ? obj[prefixKey] : undefined;
 }
 
-export function toAnswerValue(obj: Record<any, any>, prefix: string): AnswerValue | undefined {
+type ExtractAnswerProps<T> = {
+    [K in keyof T as K extends `answer${string}` ? K : never]: T[K];
+};
+type ExtractValueProps<T> = {
+    [K in keyof T as K extends `value${string}` ? K : never]: T[K];
+};
+type GenericValue = ExtractValueProps<
+    QuestionnaireResponseItemAnswer | QuestionnaireItemInitial | QuestionnaireItemAnswerOption
+>;
+type GenericAnswer = ExtractAnswerProps<QuestionnaireItemEnableWhen>;
+export function toAnswerValue(obj: GenericValue, prefix: 'value'): AnswerValue | undefined;
+
+export function toAnswerValue(obj: GenericAnswer, prefix: 'answer'): AnswerValue | undefined;
+export function toAnswerValue(obj: GenericAnswer | GenericValue, prefix: 'value' | 'answer'): AnswerValue | undefined {
     const prefixKey = Object.keys(obj).filter((key: string) => key.startsWith(prefix))[0];
-
     if (!prefixKey) {
         return undefined;
     }
@@ -835,7 +865,7 @@ export function toAnswerValue(obj: Record<any, any>, prefix: string): AnswerValu
     const answerKey = FHIRPrimitiveTypes.includes(key) ? key : upperFirst(key);
 
     return {
-        [answerKey]: obj[prefixKey],
+        [answerKey]: (obj as any)[prefixKey],
     };
 }
 
@@ -857,10 +887,16 @@ export function getAnswerValues(answers: FormAnswerItems[]) {
     return _.reject(answers, ({ value }) => isAnswerValueEmpty(value)).map(({ value }) => value!);
 }
 
-export function isAnswerValueEmpty(value: { [x: string]: any } | undefined | null) {
+export function isAnswerValueEmpty(value: AnswerValue | undefined | null) {
     return isValueEmpty(value) || _.every(_.mapValues(value, isValueEmpty));
 }
 
+export function cleanFormAnswerItems(answerItems: (FormAnswerItems | undefined)[] | undefined): FormAnswerItems[] {
+    // TODO: answerItems might be any here, we use _.filter because it handles object and nulls.
+    // TODO: get rid of it, once we have right types for all other functions
+    return _.filter(answerItems, (answer) => !!answer).filter((answer) => !isAnswerValueEmpty(answer.value));
+}
+
 export function isValueEmpty(value: any) {
     if (_.isNaN(value)) {
         console.warn(