sdc-qrf 0.2.0 → 0.3.1

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

@@ -0,0 +1,194 @@
+import {
+    Quantity as QuantityFHIR,
+    QuestionnaireItemEnableWhen as FHIRQuestionnaireItemEnableWhen,
+    QuestionnaireItem as FHIRQuestionnaireItem,
+    QuestionnaireItemAnswerOption as FHIRQuestionnaireItemAnswerOption,
+    QuestionnaireItemInitial as FHIRQuestionnaireItemInitial,
+} from 'fhir/r4b';
+
+import {
+    QuestionnaireItem as FCEQuestionnaireItem,
+    QuestionnaireItemEnableWhen as FCEQuestionnaireItemEnableWhen,
+    QuestionnaireItemEnableWhenAnswer as FCEQuestionnaireItemEnableWhenAnswer,
+    QuestionnaireItemAnswerOption as FCEQuestionnaireItemAnswerOption,
+    QuestionnaireItemInitial as FCEQuestionnaireItemInitial,
+} from 'shared/src/contrib/aidbox';
+
+import {
+    convertFromFHIRExtension,
+    convertToFHIRExtension,
+    toFHIRReference,
+} from '../../../converter';
+
+export function processItems(items: FCEQuestionnaireItem[]): FHIRQuestionnaireItem[] {
+    return items.map((item) => {
+        const extensions = convertToFHIRExtension(item);
+        if (extensions.length > 0) {
+            const fieldsToOmit = extensions
+                .map(convertFromFHIRExtension)
+                .filter((ext): ext is Partial<FCEQuestionnaireItem> => ext !== undefined)
+                .flatMap(Object.keys);
+            for (const field of fieldsToOmit) {
+                delete item[field];
+            }
+            item.extension = extensions.sort();
+        }
+
+        const {
+            enableBehavior,
+            enableWhen,
+            answerOption,
+            initial,
+            item: nestedItems,
+            type,
+            ...commonOptions
+        } = item;
+
+        const fhirItem: FHIRQuestionnaireItem = {
+            ...commonOptions,
+            type: type as FHIRQuestionnaireItem['type'],
+        };
+
+        if (answerOption !== undefined) {
+            fhirItem.answerOption = processAnswerOption(answerOption);
+        }
+
+        if (enableBehavior !== undefined) {
+            fhirItem.enableBehavior = enableBehavior as FHIRQuestionnaireItem['enableBehavior'];
+        }
+
+        if (enableWhen !== undefined) {
+            fhirItem.enableWhen = processEnableWhen(enableWhen);
+        }
+
+        if (initial) {
+            fhirItem.initial = processInitial(initial);
+        }
+
+        if (nestedItems) {
+            fhirItem.item = processItems(nestedItems);
+        }
+
+        return fhirItem;
+    });
+}
+
+const convertEnableWhen = (
+    answer: FCEQuestionnaireItemEnableWhenAnswer,
+    answerType: string,
+    result: FHIRQuestionnaireItemEnableWhen,
+) => {
+    if (answer[answerType] !== undefined) {
+        switch (answerType) {
+            case 'boolean':
+                result.answerBoolean = answer[answerType];
+                break;
+            case 'decimal':
+                result.answerDecimal = answer[answerType];
+                break;
+            case 'integer':
+                result.answerInteger = answer[answerType];
+                break;
+            case 'date':
+                result.answerDate = answer[answerType];
+                break;
+            case 'dateTime':
+                result.answerDateTime = answer[answerType];
+                break;
+            case 'time':
+                result.answerTime = answer[answerType];
+                break;
+            case 'string':
+                result.answerString = answer[answerType];
+                break;
+            case 'Coding':
+                result.answerCoding = answer[answerType];
+                break;
+            case 'Quantity':
+                result.answerQuantity = answer[answerType] as QuantityFHIR;
+                break;
+            case 'Reference':
+                result.answerReference = toFHIRReference(answer[answerType]);
+                break;
+            default:
+                break;
+        }
+    }
+};
+
+function processAnswerOption(
+    options: FCEQuestionnaireItemAnswerOption[],
+): FHIRQuestionnaireItemAnswerOption[] {
+    return options.map((option) => {
+        const { value, ...commonOptions } = option;
+
+        const fhirOption: FHIRQuestionnaireItemAnswerOption = { ...commonOptions };
+
+        if (value?.Coding) {
+            fhirOption.valueCoding = value.Coding;
+        }
+        if (value?.string) {
+            fhirOption.valueString = value.string;
+        }
+        if (value?.Reference) {
+            fhirOption.valueReference = toFHIRReference(value.Reference);
+        }
+        if (value?.date) {
+            fhirOption.valueDate = value.date;
+        }
+        if (value?.integer) {
+            fhirOption.valueInteger = value.integer;
+        }
+        if (value?.time) {
+            fhirOption.valueTime = value.time;
+        }
+
+        return fhirOption;
+    });
+}
+
+function processEnableWhen(options: FCEQuestionnaireItemEnableWhen[]) {
+    return options.map((item: FCEQuestionnaireItemEnableWhen) => {
+        const { question, operator, answer } = item;
+        const result: FHIRQuestionnaireItemEnableWhen = {
+            question,
+            operator: operator as 'exists' | '=' | '!=' | '>' | '<' | '>=' | '<=',
+        };
+
+        if (!answer) {
+            return result;
+        }
+
+        const answerTypes = [
+            'boolean',
+            'decimal',
+            'integer',
+            'date',
+            'dateTime',
+            'time',
+            'string',
+            'Coding',
+            'Quantity',
+            'Reference',
+        ];
+
+        answerTypes.forEach((answerType) => {
+            convertEnableWhen(answer, answerType, result);
+        });
+
+        return result;
+    });
+}
+
+function processInitial(options: FCEQuestionnaireItemInitial[]): FHIRQuestionnaireItemInitial[] {
+    return options.map((entry) => {
+        const result: FHIRQuestionnaireItemInitial = {};
+        if (entry.value?.boolean !== undefined) {
+            result.valueBoolean = entry.value.boolean;
+        }
+        if (entry.value?.Coding !== undefined) {
+            result.valueCoding = entry.value.Coding;
+        }
+        return result;
+    });
+}

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

@@ -0,0 +1,19 @@
+import { Meta as FHIRMeta } from 'fhir/r4b';
+
+import { Meta as FCEMeta } from 'shared/src/contrib/aidbox';
+
+export function processMeta(meta: FCEMeta): FHIRMeta {
+    const { createdAt, ...fhirMeta } = meta;
+
+    if (createdAt) {
+        fhirMeta.extension = [
+            ...(meta.extension ?? []),
+            {
+                url: 'ex:createdAt',
+                valueInstant: createdAt,
+            },
+        ];
+    }
+
+    return fhirMeta;
+}

package/src/converter/fceToFhir/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: FCEQuestionnaireResponse,
+): FHIRQuestionnaireResponse {
+    questionnaireResponse = cloneDeep(questionnaireResponse);
+    if (questionnaireResponse.item) {
+        processAnswers(questionnaireResponse.item);
+    }
+    questionnaireResponse.meta = questionnaireResponse.meta
+        ? processMeta(questionnaireResponse.meta)
+        : questionnaireResponse.meta;
+    return processReference(questionnaireResponse);
+}

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

@@ -0,0 +1,53 @@
+import { QuestionnaireResponseItemAnswer as FHIRQuestionnaireResponseItemAnswer } from 'fhir/r4b';
+import isEmpty from 'lodash/isEmpty';
+
+import {
+    QuestionnaireResponseItem as FCEQuestionnaireResponseItem,
+    QuestionnaireResponseItemAnswer as FCEQuestionnaireResponseItemAnswer,
+} from 'shared/src/contrib/aidbox';
+
+import { toFHIRReference } from '../../../converter';
+
+export function processAnswers(items: FCEQuestionnaireResponseItem[]) {
+    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(
+    answerItem: FCEQuestionnaireResponseItemAnswer,
+): FHIRQuestionnaireResponseItemAnswer {
+    if (!answerItem.value) {
+        return answerItem;
+    }
+    const { value, ...item } = answerItem;
+    const fhirAnswerItem: FHIRQuestionnaireResponseItemAnswer = item;
+    const valueMappings = {
+        string: 'valueString',
+        decimal: 'valueDecimal',
+        integer: 'valueInteger',
+        boolean: 'valueBoolean',
+        Coding: 'valueCoding',
+        date: 'valueDate',
+        dateTime: 'valueDateTime',
+        time: 'valueTime',
+    };
+    for (const key in valueMappings) {
+        if (key in value) {
+            const newKey = valueMappings[key];
+            if (newKey) {
+                fhirAnswerItem[newKey] = value[key];
+            }
+            break;
+        }
+    }
+    if (value.Reference) {
+        fhirAnswerItem.valueReference = toFHIRReference(value.Reference);
+    }
+    return fhirAnswerItem;
+}

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

@@ -0,0 +1,16 @@
+import { Meta as FHIRMeta } from 'fhir/r4b';
+
+import { Meta as FCEMeta } from 'shared/src/contrib/aidbox';
+
+export function processMeta(meta: FCEMeta): FHIRMeta {
+    const { createdAt, ...fhirMeta } = meta;
+    if (createdAt) {
+        fhirMeta.extension = [
+            {
+                url: 'ex:createdAt',
+                valueInstant: meta.createdAt,
+            },
+        ];
+    }
+    return fhirMeta;
+}

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

@@ -0,0 +1,24 @@
+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 fhirQuestionnaireResponse: FHIRQuestionnaireResponse =
+        commonProprties as FHIRQuestionnaireResponse;
+    if (encounter && encounter.resourceType && encounter.id) {
+        const { id, resourceType, ...encounterProperties } = encounter;
+        fhirQuestionnaireResponse.encounter = {
+            reference: `${resourceType}/${id}`,
+            ...encounterProperties,
+        };
+    }
+    if (source && source.resourceType && source.id) {
+        const { id, resourceType, ...sourceProperties } = source;
+        fhirQuestionnaireResponse.source = {
+            reference: `${resourceType}/${id}`,
+            ...sourceProperties,
+        };
+    }
+    return fhirQuestionnaireResponse;
+}

package/src/converter/fhirToFce/index.ts

@@ -0,0 +1,27 @@
+import {
+    Questionnaire as FHIRQuestionnaire,
+    QuestionnaireResponse as FHIRQuestionnaireResponse,
+} from 'fhir/r4b';
+
+import {
+    Questionnaire as FCEQuestionnaire,
+    QuestionnaireResponse as FCEQuestionnaireResponse,
+} from 'shared/src/contrib/aidbox';
+
+import { convertQuestionnaire } from './questionnaire';
+import { convertQuestionnaireResponse } from './questionnaireResponse';
+
+export function toFirstClassExtension(
+    fhirQuestionnaireResponse: FHIRQuestionnaireResponse,
+): FCEQuestionnaireResponse;
+export function toFirstClassExtension(fhirQuestionnaire: FHIRQuestionnaire): FCEQuestionnaire;
+export function toFirstClassExtension(
+    fhirResource: FHIRQuestionnaire | FHIRQuestionnaireResponse,
+): FCEQuestionnaireResponse | FCEQuestionnaire {
+    switch (fhirResource.resourceType) {
+        case 'Questionnaire':
+            return convertQuestionnaire(fhirResource);
+        case 'QuestionnaireResponse':
+            return convertQuestionnaireResponse(fhirResource);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Questionnaire as FHIRQuestionnaire } from 'fhir/r4b';
+import cloneDeep from 'lodash/cloneDeep';
+
+import { Questionnaire as FCEQuestionnaire } from 'shared/src/contrib/aidbox';
+
+import { processExtensions } from './processExtensions';
+import { processItems } from './processItems';
+import { processMeta } from './processMeta';
+import { checkFhirQuestionnaireProfile, trimUndefined } from '../utils';
+
+export function convertQuestionnaire(fhirQuestionnaire: FHIRQuestionnaire): FCEQuestionnaire {
+    checkFhirQuestionnaireProfile(fhirQuestionnaire);
+    fhirQuestionnaire = cloneDeep(fhirQuestionnaire);
+    const meta = processMeta(fhirQuestionnaire);
+    const item = processItems(fhirQuestionnaire);
+    const extensions = processExtensions(fhirQuestionnaire);
+    const questionnaire = trimUndefined({
+        ...fhirQuestionnaire,
+        meta,
+        item,
+        ...extensions,
+        extension: undefined,
+    });
+    return questionnaire as unknown as FCEQuestionnaire;
+}

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

@@ -0,0 +1,113 @@
+import { Questionnaire as FHIRQuestionnaire } from 'fhir/r4b';
+
+export function processExtensions(fhirQuestionnaire: FHIRQuestionnaire): {
+    launchContext?: any[];
+    mapping?: any[];
+    sourceQueries?: any[];
+    targetStructureMap?: any[];
+} {
+    const launchContext = processLaunchContext(fhirQuestionnaire);
+    const mapping = processMapping(fhirQuestionnaire);
+    const sourceQueries = processSourceQueries(fhirQuestionnaire);
+    const targetStructureMap = processTargetStructureMap(fhirQuestionnaire);
+
+    return {
+        launchContext: launchContext?.length ? launchContext : undefined,
+        mapping: mapping?.length ? mapping : undefined,
+        sourceQueries: sourceQueries?.length ? sourceQueries : undefined,
+        targetStructureMap: targetStructureMap?.length ? targetStructureMap : undefined,
+    };
+}
+
+export function processLaunchContext(fhirQuestionnaire: FHIRQuestionnaire): any[] | undefined {
+    let launchContextExtensions = fhirQuestionnaire.extension ?? [];
+
+    launchContextExtensions = launchContextExtensions.filter(
+        (ext) =>
+            ext.url ===
+            'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-launchContext',
+    );
+
+    if (launchContextExtensions.length === 0) {
+        return undefined;
+    }
+
+    const launchContextArray = [];
+    for (const launchContextExtension of launchContextExtensions) {
+        const nameExtension = launchContextExtension.extension?.find((ext) => ext.url === 'name');
+        const typeExtensions = launchContextExtension.extension?.filter(
+            (ext) => ext.url === 'type',
+        );
+        const descriptionExtension = launchContextExtension.extension?.find(
+            (ext) => ext.url === 'description',
+        );
+
+        const nameCode = nameExtension?.valueCoding?.code;
+        const typeCodes = typeExtensions?.map((typeExtension) => typeExtension.valueCode!);
+        const description = descriptionExtension?.valueString;
+
+        let contextFound = false;
+        for (const context of launchContextArray) {
+            if (context.name.code === nameCode) {
+                context.type.push(...(typeCodes ?? []));
+                contextFound = true;
+                break;
+            }
+        }
+
+        if (!contextFound) {
+            const context: any = {
+                name: nameExtension?.valueCoding,
+                type: typeCodes ?? [],
+            };
+            if (description) {
+                context.description = description;
+            }
+            launchContextArray.push(context);
+        }
+    }
+
+    return launchContextArray;
+}
+
+function processMapping(fhirQuestionnaire: FHIRQuestionnaire): any[] | undefined {
+    const mapperExtensions = fhirQuestionnaire.extension?.filter(
+        (ext: any) => ext.url === 'http://beda.software/fhir-extensions/questionnaire-mapper',
+    );
+
+    if (!mapperExtensions) {
+        return undefined;
+    }
+
+    return mapperExtensions.map((mapperExtension: any) => ({
+        id: mapperExtension.valueReference?.reference?.split('/')[1],
+        resourceType: 'Mapping',
+    }));
+}
+
+function processSourceQueries(fhirQuestionnaire: FHIRQuestionnaire): any[] {
+    const extensions =
+        fhirQuestionnaire.extension?.filter(
+            (ext) =>
+                ext.url ===
+                'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-sourceQueries',
+        ) ?? [];
+
+    return extensions.map((ext) => ({
+        localRef: ext.valueReference?.reference?.substring(1) ?? '',
+    }));
+}
+
+function processTargetStructureMap(fhirQuestionnaire: FHIRQuestionnaire): string[] | undefined {
+    const extensions = fhirQuestionnaire.extension?.filter(
+        (ext) =>
+            ext.url ===
+            'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-targetStructureMap',
+    );
+
+    if (!extensions) {
+        return undefined;
+    }
+
+    return extensions.map((extension) => extension.valueCanonical!);
+}

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

@@ -0,0 +1,159 @@
+import {
+    QuestionnaireItemEnableWhen as FHIRQuestionnaireItemEnableWhen,
+    Questionnaire as FHIRQuestionnaire,
+    QuestionnaireItem as FHIRQuestionnaireItem,
+    QuestionnaireItemAnswerOption as FHIRQuestionnaireItemAnswerOption,
+    QuestionnaireItemInitial as FHIRQuestionnaireItemInitial,
+} from 'fhir/r4b';
+
+import {
+    QuestionnaireItem as FCEQuestionnaireItem,
+    QuestionnaireItemEnableWhen as FCEQuestionnaireItemEnableWhen,
+    QuestionnaireItemEnableWhenAnswer as FCEQuestionnaireItemEnableWhenAnswer,
+    QuestionnaireItemAnswerOption as FCEQuestionnaireItemAnswerOption,
+    QuestionnaireItemInitial as FCEQuestionnaireItemInitial,
+} from 'shared/src/contrib/aidbox';
+
+import { convertFromFHIRExtension, findExtension, fromFHIRReference } from '../../../converter';
+import { ExtensionIdentifier } from '../../../converter/extensions';
+
+export function processItems(fhirQuestionnaire: FHIRQuestionnaire) {
+    return fhirQuestionnaire.item?.map(convertItemProperties);
+}
+
+function convertItemProperties(item: FHIRQuestionnaireItem): FCEQuestionnaireItem {
+    const updatedProperties = getUpdatedPropertiesFromItem(item);
+    const newItem = { ...item, ...updatedProperties };
+
+    newItem.item = item.item?.map((nestedItem) => convertItemProperties(nestedItem));
+
+    if (newItem.extension) {
+        delete newItem.extension;
+    }
+
+    return newItem;
+}
+
+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);
+        if (extension !== undefined) {
+            updatedProperties = {
+                ...updatedProperties,
+                ...convertFromFHIRExtension(extension),
+            };
+        }
+    }
+
+    updatedProperties.answerOption = item.answerOption?.map(processItemOption);
+    updatedProperties.initial = item.initial?.map(processItemOption);
+    updatedProperties.enableWhen = item.enableWhen?.map(processEnableWhenItem);
+
+    return updatedProperties;
+}
+
+function processEnableWhenItem(
+    item: FHIRQuestionnaireItemEnableWhen,
+): FCEQuestionnaireItemEnableWhen {
+    return {
+        question: item.question,
+        operator: item.operator,
+        answer: processEnableWhenAnswerOption(item),
+    };
+}
+
+function processEnableWhenAnswerOption(item: FHIRQuestionnaireItemEnableWhen) {
+    const answer: FCEQuestionnaireItemEnableWhenAnswer = {};
+
+    switch (true) {
+        case 'answerBoolean' in item:
+            answer['boolean'] = item.answerBoolean;
+            break;
+        case 'answerDecimal' in item:
+            answer['decimal'] = item.answerDecimal;
+            break;
+        case 'answerInteger' in item:
+            answer['integer'] = item.answerInteger;
+            break;
+        case 'answerDate' in item:
+            answer['date'] = item.answerDate;
+            break;
+        case 'answerDateTime' in item:
+            answer['dateTime'] = item.answerDateTime;
+            break;
+        case 'answerTime' in item:
+            answer['time'] = item.answerTime;
+            break;
+        case 'answerString' in item:
+            answer['string'] = item.answerString;
+            break;
+        case 'answerCoding' in item:
+            answer['Coding'] = item.answerCoding;
+            break;
+        case 'answerQuantity' in item:
+            answer['Quantity'] = item.answerQuantity;
+            break;
+        case 'answerReference' in item:
+            if (item.answerReference) {
+                answer['Reference'] = fromFHIRReference(item.answerReference);
+            } else {
+                throw Error("Can not process 'answerReference' with no reference inside");
+            }
+            break;
+        default:
+            break;
+    }
+
+    return answer;
+}
+
+function processItemOption(
+    option: FHIRQuestionnaireItemAnswerOption | FHIRQuestionnaireItemInitial,
+): FCEQuestionnaireItemAnswerOption | FCEQuestionnaireItemInitial {
+    if (option.valueString) {
+        return {
+            value: {
+                string: option.valueString,
+            },
+        };
+    }
+    if (option.valueCoding) {
+        return {
+            value: {
+                Coding: option.valueCoding,
+            },
+        };
+    }
+    if (option.valueReference) {
+        return {
+            value: {
+                Reference: fromFHIRReference(option.valueReference),
+            },
+        };
+    }
+    if (option.valueDate) {
+        return {
+            value: {
+                date: option.valueDate,
+            },
+        };
+    }
+    if (option.valueInteger) {
+        return {
+            value: {
+                integer: option.valueInteger,
+            },
+        };
+    }
+    if ('valueBoolean' in option) {
+        return {
+            value: {
+                boolean: option.valueBoolean,
+            },
+        };
+    }
+    return option;
+}

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

@@ -0,0 +1,17 @@
+import { Questionnaire as FHIRQuestionnaire } from 'fhir/r4b';
+
+export function processMeta(fhirQuestionnaire: FHIRQuestionnaire) {
+    const createdAt = getCreatedAt(fhirQuestionnaire);
+    return {
+        ...fhirQuestionnaire.meta,
+        ...createdAt,
+        extension: undefined,
+    };
+}
+
+function getCreatedAt(fhirQuestionnaire: FHIRQuestionnaire) {
+    const metaExtension = fhirQuestionnaire.meta?.extension?.find(
+        (ext) => ext.url === 'ex:createdAt',
+    );
+    return metaExtension ? { createdAt: metaExtension.valueInstant } : {};
+}