@olaboot/esm-form-engine-lib 4.1.0

package/dist/transformers/default-schema-transformer.js

@@ -0,0 +1,308 @@
+import { isTrue } from "../utils/boolean-utils.js";
+import { hasRendering } from "../utils/common-utils.js";
+export const DefaultFormSchemaTransformer = {
+    transform: (form, preFilledQuestions)=>{
+        parseBooleanTokenIfPresent(form, 'readonly');
+        form.pages.forEach((page, index)=>{
+            const label = page.label ?? '';
+            page.id = `page-${label.replace(/\s/g, '')}-${index}`;
+            parseBooleanTokenIfPresent(page, 'readonly');
+            if (page.sections) {
+                page.sections.forEach((section)=>{
+                    section.questions = handleQuestionsWithDateOptions(section.questions);
+                    section.questions = handleQuestionsWithObsComments(section.questions);
+                    parseBooleanTokenIfPresent(section, 'readonly');
+                    parseBooleanTokenIfPresent(section, 'isExpanded');
+                    section?.questions?.forEach((question, index)=>handleQuestion(question, page, form));
+                });
+            }
+        });
+        if (preFilledQuestions && typeof preFilledQuestions === 'object') {
+            handlePreFilledQuestions(form, preFilledQuestions);
+        }
+        if (form.meta?.programs) {
+            handleProgramMetaTags(form);
+        }
+        return form;
+    }
+};
+function handleQuestion(question, page, form) {
+    if (question.type === 'programState') {
+        const formMeta = form.meta ?? {};
+        formMeta.programs = formMeta.programs ? {
+            ...formMeta.programs,
+            hasProgramFields: true
+        } : {
+            hasProgramFields: true
+        };
+        form.meta = formMeta;
+    }
+    try {
+        sanitizeQuestion(question);
+        setFieldValidators(question);
+        transformByType(question);
+        transformByRendering(question);
+        if (question.questions?.length) {
+            if (question.type === 'obsGroup' && question.questions.length) {
+                question.questions.forEach((nestedQuestion)=>handleQuestion(nestedQuestion, page, form));
+            } else {
+                question.questions.forEach((nestedQuestion)=>handleQuestion(nestedQuestion, page, form));
+            }
+        }
+        question.meta.pageId = page.id;
+    } catch (error) {
+        console.error(error);
+    }
+}
+function handleQuestionsWithDateOptions(sectionQuestions) {
+    const augmentedQuestions = [];
+    sectionQuestions?.forEach((question)=>{
+        augmentedQuestions.push(question);
+        if (question.type !== 'inlineDate' && isTrue(question.questionOptions?.showDate)) {
+            const inlinedDate = {
+                id: `${question.id}_inline_date`,
+                label: `Date for ${question.label}`,
+                type: 'inlineDate',
+                questionOptions: {
+                    rendering: 'date',
+                    isTransient: true
+                },
+                validators: question.questionOptions.shownDateOptions?.validators,
+                disabled: {
+                    disableWhenExpression: `isEmpty(${question.id})`
+                },
+                hide: question.questionOptions.shownDateOptions?.hide || question.hide,
+                meta: {
+                    targetField: question.id,
+                    initialValue: {
+                        omrsObject: question.meta?.initialValue?.omrsObject?.obsDatetime
+                    }
+                }
+            };
+            augmentedQuestions.push(inlinedDate);
+        }
+    });
+    return augmentedQuestions;
+}
+function sanitizeQuestion(question) {
+    parseBooleanTokenIfPresent(question, 'readonly');
+    parseBooleanTokenIfPresent(question, 'required');
+    parseBooleanTokenIfPresent(question, 'unspecified');
+    parseBooleanTokenIfPresent(question.questionOptions, 'disallowDecimals');
+    parseBooleanTokenIfPresent(question.questionOptions, 'isSearchable');
+    parseBooleanTokenIfPresent(question.questionOptions, 'isTransient');
+    parseBooleanTokenIfPresent(question.questionOptions, 'enablePreviousValue');
+    parseBooleanTokenIfPresent(question.questionOptions, 'allowMultiple');
+    if (!question.meta) {
+        question.meta = {
+            submission: null,
+            initialValue: {
+                omrsObject: null,
+                refinedValue: null
+            }
+        };
+    }
+}
+function parseBooleanTokenIfPresent(node, token) {
+    if (node && typeof node[token] === 'string') {
+        const trimmed = node[token].trim().toLowerCase();
+        if (trimmed === 'true' || trimmed === 'false') {
+            node[token] = trimmed === 'true';
+        }
+    }
+    return node;
+}
+function setFieldValidators(question) {
+    if (hasRendering(question, 'group')) {
+        return;
+    }
+    question.validators = question.validators || [];
+    if (question.validators.findIndex((v)=>v.type === 'form_field') < 0) {
+        question.validators.push({
+            type: 'form_field'
+        });
+    }
+    if (question.validators.findIndex((v)=>v.type === 'default_value') < 0) {
+        question.validators.push({
+            type: 'default_value'
+        });
+    }
+}
+function transformByType(question) {
+    switch(question.type){
+        case 'encounterProvider':
+            question.questionOptions.rendering = 'encounter-provider';
+            break;
+        case 'encounterLocation':
+            question.questionOptions.rendering = 'encounter-location';
+            break;
+        case 'encounterRole':
+            question.questionOptions.rendering = 'encounter-role';
+            break;
+        case 'encounterDatetime':
+            question.questionOptions.rendering = hasRendering(question, 'ui-select-extended') ? 'date' : question.questionOptions.rendering;
+            break;
+        case 'diagnosis':
+            handleDiagnosis(question);
+            break;
+    }
+}
+function transformByRendering(question) {
+    switch(question.questionOptions.rendering){
+        case 'checkbox-searchable':
+        case 'multiCheckbox':
+            handleCheckbox(question);
+            break;
+        case 'numeric':
+            question.questionOptions.rendering = 'number';
+            break;
+        case 'select-concept-answers':
+            handleSelectConceptAnswers(question);
+            break;
+        case 'repeating':
+        case 'group':
+            handleLabOrders(question);
+            break;
+        case 'date':
+            question.datePickerFormat = question.datePickerFormat ?? 'calendar';
+            break;
+        case 'datetime':
+            question.datePickerFormat = question.datePickerFormat ?? 'both';
+            break;
+        case 'workspace-launcher':
+            question.type = 'control';
+            break;
+        case 'markdown':
+            question.type = 'control';
+            break;
+        case 'drug':
+        case 'problem':
+            question.questionOptions.isSearchable = true;
+            break;
+    }
+    return question;
+}
+function handleCheckbox(question) {
+    if (question.questionOptions.rendering === 'multiCheckbox') {
+        question.questionOptions.rendering = 'checkbox-searchable';
+        if (isTrue(question.inlineMultiCheckbox)) {
+            question.questionOptions.rendering = 'checkbox';
+        }
+    }
+    if (hasRendering(question, 'checkbox-searchable')) {
+        question.questionOptions.rendering = 'checkbox';
+        question.questionOptions.isCheckboxSearchable = true;
+    }
+}
+function handleLabOrders(question) {
+    if (hasRendering(question, 'group') && question.questions?.length) {
+        question.questions.forEach(handleLabOrders);
+    }
+    if (question.type === 'testOrder' && question.questionOptions.selectableOrders?.length) {
+        question.questionOptions.answers = question.questionOptions.selectableOrders || [];
+        delete question.questionOptions.selectableOrders;
+    }
+}
+function handleSelectConceptAnswers(question) {
+    question.questionOptions.isSearchable = true;
+    if (!question.questionOptions.datasource?.config) {
+        question.questionOptions.datasource = {
+            name: 'select_concept_answers_datasource',
+            config: {
+                concept: question.questionOptions.concept
+            }
+        };
+    }
+}
+function handleProgramMetaTags(form) {
+    if (form.meta.programs.isEnrollment || form.meta.programs.discontinuationDateQuestionId) {
+        const config = {
+            programUuid: form.meta.programs.uuid
+        };
+        if (form.meta.programs.isEnrollment) {
+            config['enrollmentDate'] = '';
+        } else {
+            config['completionDate'] = form.meta.programs.discontinuationDateQuestionId;
+        }
+        form.postSubmissionActions = [
+            {
+                actionId: 'ProgramEnrollmentSubmissionAction',
+                enabled: 'true',
+                config
+            }
+        ];
+    }
+}
+function handleQuestionsWithObsComments(sectionQuestions) {
+    const augmentedQuestions = [];
+    sectionQuestions?.forEach((question)=>{
+        augmentedQuestions.push(question);
+        if (question.type !== 'obsComment' && isTrue(question.questionOptions?.showComment)) {
+            const obsComment = {
+                id: `${question.id}_obs_comment`,
+                label: `Comment for ${question.label}`,
+                type: 'obsComment',
+                questionOptions: {
+                    rendering: 'text',
+                    isTransient: true
+                },
+                validators: question.questionOptions.shownCommentOptions?.validators,
+                disabled: {
+                    disableWhenExpression: `isEmpty(${question.id})`
+                },
+                hide: question.questionOptions.shownCommentOptions?.hide || question.hide,
+                meta: {
+                    targetField: question.id,
+                    initialValue: {
+                        omrsObject: question.meta?.initialValue?.omrsObject?.comment
+                    }
+                }
+            };
+            augmentedQuestions.push(obsComment);
+        }
+    });
+    return augmentedQuestions;
+}
+function handleDiagnosis(question) {
+    if ('dataSource' in question.questionOptions && question.questionOptions['dataSource'] === 'diagnoses' || question.type === 'diagnosis') {
+        question.questionOptions.datasource = {
+            name: 'problem_datasource',
+            config: {
+                class: question.questionOptions.diagnosis?.conceptClasses
+            }
+        };
+        if (question.questionOptions.diagnosis?.conceptSet) {
+            question.questionOptions = {
+                ...question.questionOptions,
+                concept: question.questionOptions.diagnosis?.conceptSet,
+                datasource: {
+                    name: 'problem_datasource',
+                    config: {
+                        useSetMembersByConcept: true
+                    }
+                }
+            };
+        }
+        question.questionOptions.isSearchable = true;
+        delete question.questionOptions['dataSource'];
+    }
+}
+function handlePreFilledQuestions(form, preFilledQuestions) {
+    Object.entries(preFilledQuestions).forEach(([preFilledQnId, preFilledValue])=>{
+        form?.pages.forEach((page)=>{
+            page.sections.forEach((section)=>{
+                section.questions.forEach((question)=>{
+                    if (question.id === preFilledQnId) {
+                        question.questionOptions.defaultValue = preFilledValue;
+                    } else if (Array.isArray(question?.questions) && question.questions.length > 0) {
+                        question.questions.forEach((question)=>{
+                            if (question.id === preFilledQnId) {
+                                question.questionOptions.defaultValue = preFilledValue;
+                            }
+                        });
+                    }
+                });
+            });
+        });
+    });
+}

package/dist/transformers/default-schema-transformer.test.js

@@ -0,0 +1,319 @@
+import { DefaultFormSchemaTransformer } from "./default-schema-transformer.js";
+import { testForm } from "__mocks__/forms";
+const expectedTransformedSchema = {
+    name: 'AFE form with aliased questions',
+    readonly: false,
+    pages: [
+        {
+            label: 'Page 1',
+            readonly: false,
+            id: 'page-Page1-0',
+            sections: [
+                {
+                    label: 'Section 1',
+                    isExpanded: true,
+                    questions: [
+                        {
+                            label: 'Multi Checkbox',
+                            type: 'obs',
+                            required: true,
+                            id: 'dem_multi_checkbox',
+                            questionOptions: {
+                                rendering: 'checkbox',
+                                isCheckboxSearchable: true
+                            },
+                            validators: [
+                                {
+                                    type: 'form_field'
+                                },
+                                {
+                                    type: 'default_value'
+                                }
+                            ],
+                            meta: {
+                                submission: null,
+                                pageId: 'page-Page1-0',
+                                initialValue: {
+                                    omrsObject: null,
+                                    refinedValue: null
+                                }
+                            }
+                        },
+                        {
+                            label: 'Numeric',
+                            id: 'dem_numeric',
+                            type: 'obs',
+                            required: false,
+                            questionOptions: {
+                                rendering: 'number'
+                            },
+                            validators: [
+                                {
+                                    type: 'form_field'
+                                },
+                                {
+                                    type: 'default_value'
+                                }
+                            ],
+                            meta: {
+                                submission: null,
+                                pageId: 'page-Page1-0',
+                                initialValue: {
+                                    omrsObject: null,
+                                    refinedValue: null
+                                }
+                            }
+                        },
+                        {
+                            label: 'Encounter Provider',
+                            id: 'dem_encounter_provider',
+                            type: 'encounterProvider',
+                            required: false,
+                            questionOptions: {
+                                rendering: 'encounter-provider'
+                            },
+                            validators: [
+                                {
+                                    type: 'form_field'
+                                },
+                                {
+                                    type: 'default_value'
+                                }
+                            ],
+                            meta: {
+                                submission: null,
+                                pageId: 'page-Page1-0',
+                                initialValue: {
+                                    omrsObject: null,
+                                    refinedValue: null
+                                }
+                            }
+                        },
+                        {
+                            id: 'dem_encounter_location',
+                            type: 'obsGroup',
+                            required: false,
+                            questionOptions: {
+                                rendering: 'group'
+                            },
+                            questions: [
+                                {
+                                    label: 'Encounter Location',
+                                    type: 'encounterLocation',
+                                    required: false,
+                                    questionOptions: {
+                                        rendering: 'encounter-location'
+                                    },
+                                    validators: [
+                                        {
+                                            type: 'form_field'
+                                        },
+                                        {
+                                            type: 'default_value'
+                                        }
+                                    ],
+                                    meta: {
+                                        submission: null,
+                                        pageId: 'page-Page1-0',
+                                        initialValue: {
+                                            omrsObject: null,
+                                            refinedValue: null
+                                        }
+                                    }
+                                }
+                            ],
+                            meta: {
+                                submission: null,
+                                pageId: 'page-Page1-0',
+                                initialValue: {
+                                    omrsObject: null,
+                                    refinedValue: null
+                                }
+                            }
+                        },
+                        {
+                            id: 'labOrder',
+                            type: 'testOrder',
+                            label: 'Add Lab Order',
+                            required: true,
+                            questionOptions: {
+                                rendering: 'repeating',
+                                concept: 'f1742346-cf43-4a17-8c98-720e3f487fc0',
+                                orderType: 'testorder',
+                                orderSettingUuid: 'INPATIENT',
+                                repeatOptions: {
+                                    limit: 2
+                                },
+                                answers: [
+                                    {
+                                        concept: '30e2da8f-34ca-4c93-94c8-d429f22d381c',
+                                        label: 'Option 1'
+                                    },
+                                    {
+                                        concept: '143264AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+                                        label: 'Option 2'
+                                    }
+                                ]
+                            },
+                            validators: [
+                                {
+                                    type: 'form_field'
+                                },
+                                {
+                                    type: 'default_value'
+                                }
+                            ],
+                            meta: {
+                                submission: null,
+                                pageId: 'page-Page1-0',
+                                initialValue: {
+                                    omrsObject: null,
+                                    refinedValue: null
+                                }
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+};
+describe('Default form schema transformer', ()=>{
+    it('should transform AFE schema to be compatible with RFE', ()=>{
+        expect(DefaultFormSchemaTransformer.transform(testForm)).toEqual(expectedTransformedSchema);
+    });
+    it('should handle checkbox-searchable rendering', ()=>{
+        // setup
+        const form = {
+            pages: [
+                {
+                    sections: [
+                        {
+                            questions: [
+                                {
+                                    label: 'Searchable Checkbox',
+                                    type: 'obs',
+                                    questionOptions: {
+                                        rendering: 'checkbox-searchable'
+                                    },
+                                    id: 'searchableCheckbox'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        // exercise
+        const transformedForm = DefaultFormSchemaTransformer.transform(form);
+        const transformedQuestion = transformedForm.pages[0].sections[0].questions[0];
+        // verify
+        expect(transformedQuestion.questionOptions.rendering).toEqual('checkbox');
+        expect(transformedQuestion.questionOptions.isCheckboxSearchable).toEqual(true);
+    });
+    it('should handle multiCheckbox rendering', ()=>{
+        // setup
+        const form = {
+            pages: [
+                {
+                    sections: [
+                        {
+                            questions: [
+                                {
+                                    label: 'Multi Checkbox',
+                                    type: 'obs',
+                                    questionOptions: {
+                                        rendering: 'multiCheckbox'
+                                    },
+                                    id: 'multiCheckboxField'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+    });
+    it('should handle pre-filled questions', ()=>{
+        const form = {
+            pages: [
+                {
+                    sections: [
+                        {
+                            questions: [
+                                {
+                                    id: 'question1',
+                                    type: 'obs',
+                                    questionOptions: {}
+                                },
+                                {
+                                    id: 'nestedGroup',
+                                    type: 'obsGroup',
+                                    questionOptions: {
+                                        rendering: 'group'
+                                    },
+                                    questions: [
+                                        {
+                                            id: 'nestedQuestion1',
+                                            type: 'obs',
+                                            questionOptions: {}
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const preFilledQuestions = {
+            question1: 'prefilledValue1',
+            nestedQuestion1: 'prefilledValue2'
+        };
+        const transformedForm = DefaultFormSchemaTransformer.transform(form, preFilledQuestions);
+        expect(transformedForm.pages[0].sections[0].questions[0].questionOptions.defaultValue).toEqual('prefilledValue1');
+        expect(transformedForm.pages[0].sections[0].questions[1].questions[0].questionOptions.defaultValue).toEqual('prefilledValue2');
+    });
+    it('should not modify questions when no pre-filled questions are provided', ()=>{
+        const form = {
+            pages: [
+                {
+                    sections: [
+                        {
+                            questions: [
+                                {
+                                    id: 'question1',
+                                    type: 'obs',
+                                    questionOptions: {}
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const transformedForm = DefaultFormSchemaTransformer.transform(form);
+        expect(transformedForm.pages[0].sections[0].questions[0].questionOptions.defaultValue).toBeUndefined();
+    });
+    it('should handle empty pre-filled questions object', ()=>{
+        const form = {
+            pages: [
+                {
+                    sections: [
+                        {
+                            questions: [
+                                {
+                                    id: 'question1',
+                                    type: 'obs',
+                                    questionOptions: {}
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const transformedForm = DefaultFormSchemaTransformer.transform(form, {});
+        expect(transformedForm.pages[0].sections[0].questions[0].questionOptions.defaultValue).toBeUndefined();
+    });
+});