sdc-qrf 0.3.1 → 0.3.3

package/src/converter/extensions.ts

@@ -7,7 +7,26 @@ export enum ExtensionIdentifier {
     ItemControl = 'http://hl7.org/fhir/StructureDefinition/questionnaire-itemControl',
     SliderStepValue = 'http://hl7.org/fhir/StructureDefinition/questionnaire-sliderStepValue',
     Unit = 'http://hl7.org/fhir/StructureDefinition/questionnaire-unit',
+    UnitOption = 'http://hl7.org/fhir/StructureDefinition/questionnaire-unitOption',
     ReferenceResource = 'http://hl7.org/fhir/StructureDefinition/questionnaire-referenceResource',
+    EntryFormat = 'http://hl7.org/fhir/StructureDefinition/entryFormat',
+    ColumnSize = 'http://aidbox.io/questionnaire-itemColumnSize',
+    ItemMedia = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-itemMedia',
+    Regex = 'http://hl7.org/fhir/StructureDefinition/regex',
+    ObservationExtract = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-observationExtract',
+    ObservationLinkPeriod = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-observationLinkPeriod',
+    MinValue = 'http://hl7.org/fhir/StructureDefinition/minValue',
+    MaxValue = 'http://hl7.org/fhir/StructureDefinition/maxValue',
+    MinQuantity = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-minQuantity',
+    MaxQuantity = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-maxQuantity',
+    ShowOrdinalValue = 'http://aidbox.io/questionnaire-showOrdinalValue',
+    PreferredTerminologyServer = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-preferredTerminologyServer',
+    OpenLabel = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-openLabel',
+    BackgroundImage = 'http://aidbox.io/questionnaire-backgroundImage',
+    Language = 'http://hl7.org/fhir/StructureDefinition/language',
+    ChoiceOrientation = 'http://hl7.org/fhir/StructureDefinition/questionnaire-choiceOrientation',
+    InlineChoiceDirection = 'https://beda.software/fhir-emr-questionnaire/inline-choice-direction',
+    ChoiceColumns = 'http://aidbox.io/fhir/StructureDefinition/questionnaire-choiceColumns',
 
     ItemPopulationContext = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-itemPopulationContext',
     InitialExpression = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-initialExpression',
@@ -22,6 +41,7 @@ export enum ExtensionIdentifier {
     HelpText = 'https://beda.software/fhir-emr-questionnaire/help-text',
     StopLabel = 'https://beda.software/fhir-emr-questionnaire/slider-stop-label',
     Macro = 'https://beda.software/fhir-emr-questionnaire/macro',
+    RowsNumber = 'https://beda.software/fhir-emr-questionnaire/rows-number',
 }
 
 export type ExtensionTransformer = {
@@ -52,9 +72,18 @@ export const extensionTransformers: ExtensionTransformer = {
     [ExtensionIdentifier.SliderStepValue]: {
         path: { extension: 'valueInteger', questionnaire: 'sliderStepValue' },
     },
+    [ExtensionIdentifier.EntryFormat]: {
+        path: { extension: 'valueString', questionnaire: 'entryFormat' },
+    },
     [ExtensionIdentifier.Unit]: {
         path: { extension: 'valueCoding', questionnaire: 'unit' },
     },
+    [ExtensionIdentifier.UnitOption]: {
+        path: { extension: 'valueCoding', questionnaire: 'unitOption' },
+    },
+    [ExtensionIdentifier.RowsNumber]: {
+        path: { extension: 'valueInteger', questionnaire: 'rowsNumber' },
+    },
     [ExtensionIdentifier.ReferenceResource]: {
         transform: {
             fromExtension: (extension) => {
@@ -74,6 +103,69 @@ export const extensionTransformers: ExtensionTransformer = {
             },
         },
     },
+    [ExtensionIdentifier.ColumnSize]: {
+        path: { extension: 'valueInteger', questionnaire: 'columnSize' },
+    },
+    [ExtensionIdentifier.ItemMedia]: {
+        path: { extension: 'valueAttachment', questionnaire: 'itemMedia' },
+    },
+    [ExtensionIdentifier.Regex]: {
+        path: { extension: 'valueString', questionnaire: 'regex' },
+    },
+    [ExtensionIdentifier.ObservationExtract]: {
+        path: { extension: 'valueBoolean', questionnaire: 'observationExtract' },
+    },
+    [ExtensionIdentifier.ObservationLinkPeriod]: {
+        path: { extension: 'valueDuration', questionnaire: 'observationLinkPeriod' },
+    },
+    [ExtensionIdentifier.MinValue]: {
+        transform: {
+            fromExtension: (extension) => ({ minValue: extension }),
+            toExtension: (item) => item.minValue,
+        },
+    },
+    [ExtensionIdentifier.MaxValue]: {
+        transform: {
+            fromExtension: (extension) => ({ maxValue: extension }),
+            toExtension: (item) => item.maxValue,
+        },
+    },
+    [ExtensionIdentifier.MinQuantity]: {
+        transform: {
+            fromExtension: (extension) => ({ minQuantity: extension }),
+            toExtension: (item) => item.minQuantity,
+        },
+    },
+    [ExtensionIdentifier.MaxQuantity]: {
+        transform: {
+            fromExtension: (extension) => ({ maxQuantity: extension }),
+            toExtension: (item) => item.maxQuantity,
+        },
+    },
+    [ExtensionIdentifier.ShowOrdinalValue]: {
+        path: { extension: 'valueBoolean', questionnaire: 'showOrdinalValue' },
+    },
+    [ExtensionIdentifier.PreferredTerminologyServer]: {
+        path: { extension: 'valueUri', questionnaire: 'preferredTerminologyServer' },
+    },
+    [ExtensionIdentifier.OpenLabel]: {
+        path: { extension: 'valueString', questionnaire: 'openLabel' },
+    },
+    [ExtensionIdentifier.BackgroundImage]: {
+        path: { extension: 'valueAttachment', questionnaire: 'backgroundImage' },
+    },
+    [ExtensionIdentifier.Language]: {
+        path: { extension: 'valueCoding', questionnaire: 'language' },
+    },
+    [ExtensionIdentifier.ChoiceOrientation]: {
+        path: { extension: 'valueCode', questionnaire: 'choiceOrientation' },
+    },
+    [ExtensionIdentifier.InlineChoiceDirection]: {
+        path: { extension: 'valueString', questionnaire: 'choiceOrientation' },
+    },
+    [ExtensionIdentifier.ChoiceColumns]: {
+        path: { extension: 'valueInteger', questionnaire: 'choiceColumns' },
+    },
 
     [ExtensionIdentifier.ItemPopulationContext]: {
         path: { extension: 'valueExpression', questionnaire: 'itemPopulationContext' },

package/src/converter/fceToFhir/questionnaire/processItems.ts

@@ -5,6 +5,7 @@ import {
     QuestionnaireItemAnswerOption as FHIRQuestionnaireItemAnswerOption,
     QuestionnaireItemInitial as FHIRQuestionnaireItemInitial,
 } from 'fhir/r4b';
+import _ from 'lodash';
 
 import {
     QuestionnaireItem as FCEQuestionnaireItem,
@@ -14,11 +15,7 @@ import {
     QuestionnaireItemInitial as FCEQuestionnaireItemInitial,
 } from 'shared/src/contrib/aidbox';
 
-import {
-    convertFromFHIRExtension,
-    convertToFHIRExtension,
-    toFHIRReference,
-} from '../../../converter';
+import { convertFromFHIRExtension, convertToFHIRExtension, toFHIRReference } from '../..';
 
 export function processItems(items: FCEQuestionnaireItem[]): FHIRQuestionnaireItem[] {
     return items.map((item) => {
@@ -29,6 +26,7 @@ export function processItems(items: FCEQuestionnaireItem[]): FHIRQuestionnaireIt
                 .filter((ext): ext is Partial<FCEQuestionnaireItem> => ext !== undefined)
                 .flatMap(Object.keys);
             for (const field of fieldsToOmit) {
+                //@ts-ignore
                 delete item[field];
             }
             item.extension = extensions.sort();
@@ -78,6 +76,7 @@ const convertEnableWhen = (
     answerType: string,
     result: FHIRQuestionnaireItemEnableWhen,
 ) => {
+    //@ts-ignore
     if (answer[answerType] !== undefined) {
         switch (answerType) {
             case 'boolean':
@@ -124,22 +123,26 @@ function processAnswerOption(
 
         const fhirOption: FHIRQuestionnaireItemAnswerOption = { ...commonOptions };
 
-        if (value?.Coding) {
+        if (!value) {
+            return fhirOption;
+        }
+
+        if (value.Coding) {
             fhirOption.valueCoding = value.Coding;
         }
-        if (value?.string) {
+        if (value.string) {
             fhirOption.valueString = value.string;
         }
-        if (value?.Reference) {
+        if (value.Reference) {
             fhirOption.valueReference = toFHIRReference(value.Reference);
         }
-        if (value?.date) {
+        if (value.date) {
             fhirOption.valueDate = value.date;
         }
-        if (value?.integer) {
+        if (_.isNumber(value.integer)) {
             fhirOption.valueInteger = value.integer;
         }
-        if (value?.time) {
+        if (value.time) {
             fhirOption.valueTime = value.time;
         }
 

package/src/converter/fceToFhir/questionnaireResponse/processAnswers.ts

@@ -39,8 +39,10 @@ function processAnswer(
     };
     for (const key in valueMappings) {
         if (key in value) {
+            //@ts-ignore
             const newKey = valueMappings[key];
             if (newKey) {
+                //@ts-ignore
                 fhirAnswerItem[newKey] = value[key];
             }
             break;

package/src/converter/fceToFhir/questionnaireResponse/processReference.ts

@@ -3,9 +3,9 @@ import { QuestionnaireResponse as FHIRQuestionnaireResponse } from 'fhir/r4b';
 import { QuestionnaireResponse as FCEQuestionnaireResponse } from 'shared/src/contrib/aidbox';
 
 export function processReference(fceQR: FCEQuestionnaireResponse): FHIRQuestionnaireResponse {
-    const { encounter, source, ...commonProprties } = fceQR;
+    const { encounter, source, subject, ...commonProperties } = fceQR;
     const fhirQuestionnaireResponse: FHIRQuestionnaireResponse =
-        commonProprties as FHIRQuestionnaireResponse;
+        commonProperties as FHIRQuestionnaireResponse;
     if (encounter && encounter.resourceType && encounter.id) {
         const { id, resourceType, ...encounterProperties } = encounter;
         fhirQuestionnaireResponse.encounter = {
@@ -20,5 +20,12 @@ export function processReference(fceQR: FCEQuestionnaireResponse): FHIRQuestionn
             ...sourceProperties,
         };
     }
+    if (subject && subject.resourceType && subject.id) {
+        const { id, resourceType, ...subjectProperties } = subject;
+        fhirQuestionnaireResponse.subject = {
+            reference: `${resourceType}/${id}`,
+            ...subjectProperties,
+        };
+    }
     return fhirQuestionnaireResponse;
 }

package/src/converter/fhirToFce/questionnaire/processItems.ts

@@ -5,6 +5,7 @@ import {
     QuestionnaireItemAnswerOption as FHIRQuestionnaireItemAnswerOption,
     QuestionnaireItemInitial as FHIRQuestionnaireItemInitial,
 } from 'fhir/r4b';
+import _ from 'lodash';
 
 import {
     QuestionnaireItem as FCEQuestionnaireItem,
@@ -12,10 +13,11 @@ import {
     QuestionnaireItemEnableWhenAnswer as FCEQuestionnaireItemEnableWhenAnswer,
     QuestionnaireItemAnswerOption as FCEQuestionnaireItemAnswerOption,
     QuestionnaireItemInitial as FCEQuestionnaireItemInitial,
+    Coding as FCECoding,
 } from 'shared/src/contrib/aidbox';
 
 import { convertFromFHIRExtension, findExtension, fromFHIRReference } from '../../../converter';
-import { ExtensionIdentifier } from '../../../converter/extensions';
+import { ExtensionIdentifier } from '../../extensions';
 
 export function processItems(fhirQuestionnaire: FHIRQuestionnaire) {
     return fhirQuestionnaire.item?.map(convertItemProperties);
@@ -37,9 +39,20 @@ function convertItemProperties(item: FHIRQuestionnaireItem): FCEQuestionnaireIte
 function getUpdatedPropertiesFromItem(item: FHIRQuestionnaireItem) {
     let updatedProperties: FCEQuestionnaireItem = { linkId: item.linkId, type: item.type };
 
-    for (const identifer in ExtensionIdentifier) {
-        const identifierURI = ExtensionIdentifier[identifer];
-        const extension = findExtension(item, identifierURI);
+    for (const identifier of Object.values(ExtensionIdentifier)) {
+        if (identifier === ExtensionIdentifier.UnitOption) {
+            const unitOptions =
+                item.extension?.filter((ext) => ext.url === ExtensionIdentifier.UnitOption) || [];
+            if (unitOptions.length > 0) {
+                const unitOption = unitOptions.map(
+                    (ext) => convertFromFHIRExtension(ext)?.unitOption,
+                ) as FCECoding[];
+                updatedProperties = { ...updatedProperties, unitOption };
+            }
+            continue;
+        }
+
+        const extension = findExtension(item, identifier);
         if (extension !== undefined) {
             updatedProperties = {
                 ...updatedProperties,
@@ -141,7 +154,7 @@ function processItemOption(
             },
         };
     }
-    if (option.valueInteger) {
+    if (_.isNumber(option.valueInteger)) {
         return {
             value: {
                 integer: option.valueInteger,

package/src/converter/fhirToFce/questionnaireResponse/processAnswers.ts

@@ -44,8 +44,11 @@ function processAnswer(
 
     for (const key in valueHandlers) {
         if (key in fceAnswer) {
+            //@ts-ignore
             const value = fceAnswer[key];
+            //@ts-ignore
             delete fceAnswer[key];
+            //@ts-ignore
             fceAnswer.value = valueHandlers[key]?.(value);
         }
     }

package/src/converter/fhirToFce/questionnaireResponse/processMeta.ts

@@ -9,6 +9,10 @@ export function processMeta(meta: FHIRMeta): FCEMeta {
     const fceMeta: FCEMeta = { ...commonMeta };
     if (extension) {
         fceMeta.createdAt = extractExtension(extension, 'ex:createdAt');
+        const filteredExtension = extension.filter((value) => value.url !== 'ex:createdAt');
+        if (filteredExtension?.length > 0) {
+            fceMeta.extension = filteredExtension;
+        }
     }
     return fceMeta;
 }

package/src/converter/fhirToFce/questionnaireResponse/processReference.ts

@@ -7,7 +7,7 @@ import { fromFHIRReference } from '../../../converter';
 export function processReference(
     fhirQuestionnaireResponse: FHIRQuestionnaireResponse,
 ): FCEQuestionnaireResponse {
-    const { encounter, source, ...commonProperties } = fhirQuestionnaireResponse;
+    const { encounter, source, subject, ...commonProperties } = fhirQuestionnaireResponse;
     const fceQuestionnaireResponse: FCEQuestionnaireResponse =
         commonProperties as FCEQuestionnaireResponse;
     if (encounter?.reference) {
@@ -16,5 +16,8 @@ export function processReference(
     if (source?.reference) {
         fceQuestionnaireResponse.source = fromFHIRReference(source);
     }
+    if (subject?.reference) {
+        fceQuestionnaireResponse.subject = fromFHIRReference(subject);
+    }
     return fceQuestionnaireResponse;
 }

package/src/converter/fhirToFce/utils.ts

@@ -13,8 +13,7 @@ export function checkFhirQuestionnaireProfile(fhirQuestionnaire: FHIRQuestionnai
 
 export function trimUndefined(e: any) {
     for (const prop in e) {
-        // eslint-disable-next-line no-prototype-builtins
-        if (e.hasOwnProperty(prop)) {
+        if (Object.prototype.hasOwnProperty.call(e, prop)) {
             const val = e[prop];
             if (val === undefined) {
                 delete e[prop];

package/src/converter/index.ts

@@ -31,9 +31,8 @@ export function convertFromFHIRExtension(
 
 export function convertToFHIRExtension(item: FCEQuestionnaireItem): FHIRExtension[] {
     const extensions: FHIRExtension[] = [];
-    for (const identifer in ExtensionIdentifier) {
-        const transformer =
-            extensionTransformers[ExtensionIdentifier[identifer] as ExtensionIdentifier];
+    Object.values(ExtensionIdentifier).forEach((identifier) => {
+        const transformer = extensionTransformers[identifier];
         if ('transform' in transformer) {
             const extension = transformer.transform.toExtension(item);
             if (extension !== undefined) {
@@ -44,12 +43,12 @@ export function convertToFHIRExtension(item: FCEQuestionnaireItem): FHIRExtensio
             if (extensionValue !== undefined) {
                 const extension: FHIRExtension = {
                     [transformer.path.extension]: extensionValue,
-                    url: ExtensionIdentifier[identifer],
+                    url: identifier,
                 };
                 extensions.push(extension);
             }
         }
-    }
+    });
     return extensions;
 }
 

package/src/utils.ts

@@ -5,6 +5,7 @@ import isPlainObject from 'lodash/isPlainObject';
 import queryString from 'query-string';
 
 import {
+    Extension,
     Questionnaire,
     QuestionnaireItem,
     QuestionnaireItemInitial,
@@ -110,15 +111,25 @@ export function calcContext(
     qrItem: QuestionnaireResponseItem,
 ): ItemContext {
     // TODO: add root variable support
-    return {
-        ...(variables || []).reduce(
-            (acc, curVariable) => ({
-                ...acc,
-                [curVariable.name!]: fhirpath.evaluate(qrItem || {}, curVariable.expression!, acc),
-            }),
-            { ...initialContext, context: qrItem, qitem: qItem },
-        ),
-    };
+    try {
+        return {
+            ...(variables || []).reduce(
+                (acc, curVariable) => ({
+                    ...acc,
+                    [curVariable.name!]: fhirpath.evaluate(
+                        qrItem || {},
+                        curVariable.expression!,
+                        acc,
+                    ),
+                }),
+                { ...initialContext, context: qrItem, qitem: qItem },
+            ),
+        };
+    } catch (err: unknown) {
+        throw Error(
+            `FHIRPath expression evaluation failure for "variable" in ${qItem.linkId}: ${err}`,
+        );
+    }
 }
 
 export function compareValue(firstAnswerValue: AnswerValue, secondAnswerValue: AnswerValue) {
@@ -501,21 +512,25 @@ function isQuestionEnabled(args: IsQuestionEnabledArgs) {
     }
 
     if (enableWhenExpression && enableWhenExpression.language === 'text/fhirpath') {
-        const expressionResult = fhirpath.evaluate(
-            args.context.resource,
-            enableWhenExpression.expression!,
-            args.context ?? {},
-        )[0];
-
-        if (typeof expressionResult !== 'boolean') {
-            throw Error(`
-            linkId: ${args.qItem.linkId}
-            Expression result: ${expressionResult}
-            The result of enableWhenExpression is not a boolean value
-            `);
-        }
+        try {
+            const expressionResult = fhirpath.evaluate(
+                args.context.resource,
+                enableWhenExpression.expression!,
+                args.context ?? {},
+            )[0];
+
+            if (typeof expressionResult !== 'boolean') {
+                throw Error(
+                    `The result of enableWhenExpression is not a boolean value. Expression result: ${expressionResult}`,
+                );
+            }
 
-        return expressionResult;
+            return expressionResult;
+        } catch (err: unknown) {
+            throw Error(
+                `FHIRPath expression evaluation failure for "enableWhenExpression" in ${args.qItem.linkId}: ${err}`,
+            );
+        }
     }
 
     const iterFn = enableBehavior === 'any' ? _.some : _.every;
@@ -749,3 +764,7 @@ export function isValueEmpty(value: any) {
 
     return _.isFinite(value) || _.isBoolean(value) ? false : _.isEmpty(value);
 }
+
+export function findExtensionByUrl(url: string, extensionList?: Extension[]) {
+    return extensionList?.find((extension) => extension.url === url) || null;
+}