sdc-qrf 0.2.0 → 0.3.2

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

@@ -0,0 +1,21 @@
+import { QuestionnaireResponse as FHIRQuestionnaireResponse } from 'fhir/r4b';
+import cloneDeep from 'lodash/cloneDeep';
+
+import { QuestionnaireResponse as FCEQuestionnaireResponse } from 'shared/src/contrib/aidbox';
+
+import { processAnswers } from './processAnswers';
+import { processMeta } from './processMeta';
+import { processReference } from './processReference';
+
+export function convertQuestionnaireResponse(
+    questionnaireResponse: FHIRQuestionnaireResponse,
+): FCEQuestionnaireResponse {
+    questionnaireResponse = cloneDeep(questionnaireResponse);
+    if (questionnaireResponse.item) {
+        processAnswers(questionnaireResponse.item);
+    }
+    if (questionnaireResponse.meta) {
+        questionnaireResponse.meta = processMeta(questionnaireResponse.meta);
+    }
+    return processReference(questionnaireResponse);
+}

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

@@ -0,0 +1,53 @@
+import {
+    Coding as FHIRCoding,
+    QuestionnaireResponseItem as FHIRQuestionnaireResponseItem,
+    QuestionnaireResponseItemAnswer as FHIRQuestionnaireResponseItemAnswer,
+    Reference as FHIRReference,
+} from 'fhir/r4b';
+import isEmpty from 'lodash/isEmpty';
+
+import { QuestionnaireResponseItemAnswer as FCEQuestionnaireResponseItemAnswer } from 'shared/src/contrib/aidbox';
+
+import { fromFHIRReference } from '../../../converter';
+
+export function processAnswers(items: FHIRQuestionnaireResponseItem[]) {
+    if (!items) {
+        return;
+    }
+    for (const item of items) {
+        if (item.answer) {
+            item.answer = item.answer.map(processAnswer).filter((answer) => !isEmpty(answer));
+        }
+        if (item.item) {
+            processAnswers(item.item);
+        }
+    }
+}
+
+function processAnswer(
+    answer: FHIRQuestionnaireResponseItemAnswer,
+): FCEQuestionnaireResponseItemAnswer {
+    const fceAnswer: FCEQuestionnaireResponseItemAnswer = { ...answer };
+    const valueHandlers = {
+        valueString: (value: string) => ({ string: value }),
+        valueInteger: (value: number) => ({ integer: value }),
+        valueDecimal: (value: number) => ({ decimal: value }),
+        valueBoolean: (value: boolean) => ({ boolean: value }),
+        valueCoding: (value: FHIRCoding) => ({ Coding: value }),
+        valueDate: (value: string) => ({ date: value }),
+        valueDateTime: (value: string) => ({ dateTime: value }),
+        valueReference: (value: FHIRReference) => ({
+            Reference: fromFHIRReference(value),
+        }),
+        valueTime: (value: string) => ({ time: value }),
+    };
+
+    for (const key in valueHandlers) {
+        if (key in fceAnswer) {
+            const value = fceAnswer[key];
+            delete fceAnswer[key];
+            fceAnswer.value = valueHandlers[key]?.(value);
+        }
+    }
+    return fceAnswer;
+}

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

@@ -0,0 +1,14 @@
+import { Meta as FHIRMeta } from 'fhir/r4b';
+
+import { Meta as FCEMeta } from 'shared/src/contrib/aidbox';
+
+import { extractExtension } from '../../../converter';
+
+export function processMeta(meta: FHIRMeta): FCEMeta {
+    const { extension, ...commonMeta } = meta;
+    const fceMeta: FCEMeta = { ...commonMeta };
+    if (extension) {
+        fceMeta.createdAt = extractExtension(extension, 'ex:createdAt');
+    }
+    return fceMeta;
+}

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

@@ -0,0 +1,20 @@
+import { QuestionnaireResponse as FHIRQuestionnaireResponse } from 'fhir/r4b';
+
+import { QuestionnaireResponse as FCEQuestionnaireResponse } from 'shared/src/contrib/aidbox';
+
+import { fromFHIRReference } from '../../../converter';
+
+export function processReference(
+    fhirQuestionnaireResponse: FHIRQuestionnaireResponse,
+): FCEQuestionnaireResponse {
+    const { encounter, source, ...commonProperties } = fhirQuestionnaireResponse;
+    const fceQuestionnaireResponse: FCEQuestionnaireResponse =
+        commonProperties as FCEQuestionnaireResponse;
+    if (encounter?.reference) {
+        fceQuestionnaireResponse.encounter = fromFHIRReference(encounter);
+    }
+    if (source?.reference) {
+        fceQuestionnaireResponse.source = fromFHIRReference(source);
+    }
+    return fceQuestionnaireResponse;
+}

package/src/converter/fhirToFce/utils.ts

@@ -0,0 +1,36 @@
+import { Questionnaire as FHIRQuestionnaire } from 'fhir/r4b';
+
+export function checkFhirQuestionnaireProfile(fhirQuestionnaire: FHIRQuestionnaire): void {
+    if (
+        !(
+            (fhirQuestionnaire.meta?.profile?.length ?? 0) === 1 &&
+            fhirQuestionnaire.meta?.profile?.[0] === 'https://beda.software/beda-emr-questionnaire'
+        )
+    ) {
+        throw new Error('Only beda emr questionanire supported');
+    }
+}
+
+export function trimUndefined(e: any) {
+    for (const prop in e) {
+        // eslint-disable-next-line no-prototype-builtins
+        if (e.hasOwnProperty(prop)) {
+            const val = e[prop];
+            if (val === undefined) {
+                delete e[prop];
+            } else if (typeof val === 'object') {
+                if (Array.isArray(val)) {
+                    for (let i = 0; i < val.length; i++) {
+                        if (typeof val[i] === 'object') {
+                            trimUndefined(val[i]);
+                        }
+                    }
+                } else {
+                    trimUndefined(val);
+                }
+            }
+        }
+    }
+
+    return e;
+}

package/src/converter/index.ts

@@ -0,0 +1,106 @@
+import {
+    Reference as FHIRReference,
+    Extension as FHIRExtension,
+    QuestionnaireItem as FHIRQuestionnaireItem,
+} from 'fhir/r4b';
+
+import {
+    Extension as FCEExtension,
+    QuestionnaireItem as FCEQuestionnaireItem,
+    InternalReference,
+} from 'shared/src/contrib/aidbox';
+
+import { ExtensionIdentifier, extensionTransformers } from './extensions';
+import { fromFirstClassExtension } from './fceToFhir';
+import { toFirstClassExtension } from './fhirToFce';
+import { processLaunchContext as processLaunchContextToFce } from './fhirToFce/questionnaire/processExtensions';
+
+export function convertFromFHIRExtension(
+    extension: FHIRExtension,
+): Partial<FCEQuestionnaireItem> | undefined {
+    const identifier = extension.url;
+    const transformer = extensionTransformers[identifier as ExtensionIdentifier];
+    if (transformer !== undefined) {
+        if ('transform' in transformer) {
+            return transformer.transform.fromExtension(extension);
+        } else {
+            return { [transformer.path.questionnaire]: extension[transformer.path.extension] };
+        }
+    }
+}
+
+export function convertToFHIRExtension(item: FCEQuestionnaireItem): FHIRExtension[] {
+    const extensions: FHIRExtension[] = [];
+    for (const identifer in ExtensionIdentifier) {
+        const transformer =
+            extensionTransformers[ExtensionIdentifier[identifer] as ExtensionIdentifier];
+        if ('transform' in transformer) {
+            const extension = transformer.transform.toExtension(item);
+            if (extension !== undefined) {
+                extensions.push(extension);
+            }
+        } else {
+            const extensionValue = item[transformer.path.questionnaire];
+            if (extensionValue !== undefined) {
+                const extension: FHIRExtension = {
+                    [transformer.path.extension]: extensionValue,
+                    url: ExtensionIdentifier[identifer],
+                };
+                extensions.push(extension);
+            }
+        }
+    }
+    return extensions;
+}
+
+export function extractExtension(extension: FCEExtension[] | undefined, url: 'ex:createdAt') {
+    return extension?.find((e) => e.url === url)?.valueInstant;
+}
+
+export function findExtension(item: FHIRQuestionnaireItem, url: string) {
+    return item.extension?.find((ext) => ext.url === url);
+}
+
+export function fromFHIRReference(r?: FHIRReference): InternalReference | undefined {
+    if (!r || !r.reference) {
+        return undefined;
+    }
+
+    const { reference: literalReference, ...commonReferenceProperties } = r;
+    const isHistoryVersionLink = r.reference.split('/').slice(-2, -1)[0] === '_history';
+
+    if (isHistoryVersionLink) {
+        const [, , id, resourceType] = r.reference.split('/').reverse();
+
+        return {
+            ...commonReferenceProperties,
+            id: id!,
+            resourceType,
+        };
+    } else {
+        const [id, resourceType] = r.reference.split('/').reverse();
+
+        return {
+            ...commonReferenceProperties,
+            id: id!,
+            resourceType,
+        };
+    }
+}
+
+export function toFHIRReference(r?: InternalReference): FHIRReference | undefined {
+    if (!r) {
+        return undefined;
+    }
+
+    const { id, resourceType, ...commonReferenceProperties } = r;
+
+    delete commonReferenceProperties.resource;
+
+    return {
+        ...commonReferenceProperties,
+        reference: `${resourceType}/${id}`,
+    };
+}
+
+export { toFirstClassExtension, fromFirstClassExtension, processLaunchContextToFce };

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './types';
 export * from './utils';
 export * from './hooks';
 export * from './components';
+export * from './converter';

package/src/setupTests.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/src/utils.ts

@@ -110,15 +110,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) {
@@ -319,7 +329,7 @@ export function mapResponseToForm(resource: QuestionnaireResponse, questionnaire
 }
 
 function initialToQuestionnaireResponseItemAnswer(initial: QuestionnaireItemInitial[] | undefined) {
-    return (initial ?? []).map(({ value }) => ({ value } as QuestionnaireResponseItemAnswer));
+    return (initial ?? []).map(({ value }) => ({ value }) as QuestionnaireResponseItemAnswer);
 }
 
 export function findAnswersForQuestionsRecursive(linkId: string, values?: FormItems): any | null {
@@ -433,7 +443,8 @@ export function getChecker(
         return (values, answerValue) => {
             const answersLength = _.reject(
                 values,
-                (value) => _.isEmpty(value.value) || _.every(_.mapValues(value.value, _.isEmpty)),
+                (value) =>
+                    isValueEmpty(value.value) || _.every(_.mapValues(value.value, isValueEmpty)),
             ).length;
             const answer = answerValue?.boolean ?? true;
             return answersLength > 0 === answer;
@@ -500,21 +511,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;
@@ -738,3 +753,13 @@ export function parseFhirQueryExpression(expression: string, context: ItemContex
 
     return [resourceType, searchParams];
 }
+
+export function isValueEmpty(value: any) {
+    if (_.isNaN(value)) {
+        console.warn(
+            'Please be aware that a NaN value has been detected. In the context of an "exist" operator, a NaN value is interpreted as a non-existent value. This may lead to unexpected behavior in your code. Ensure to handle or correct this to maintain the integrity of your application.',
+        );
+    }
+
+    return _.isFinite(value) || _.isBoolean(value) ? false : _.isEmpty(value);
+}