@olaboot/esm-form-engine-lib 4.1.0

package/dist/utils/post-submission-action-helper.js

@@ -0,0 +1,57 @@
+export function evaluatePostSubmissionExpression(expression, encounters) {
+    const encounter = encounters[0];
+    const regx = /(?:\w+|'(?:\\'|[^'\n])*')/g;
+    let match;
+    const fieldIds = new Set();
+    try {
+        while(match = regx.exec(expression)){
+            const value = match[0].replace(/\\'/g, "'"); // Replace escaped single quotes
+            const isBoolean = /^(true|false)$/i.test(value);
+            const isNumber = /^-?\d+$/.test(value);
+            const isFloat = /^-?\d+\.\d+$/.test(value);
+            if (!(value.startsWith("'") && value.endsWith("'")) && typeof value === 'string' && !isBoolean && !isNumber && !isFloat) {
+                fieldIds.add(value);
+            }
+        }
+        let fieldToValueMap = {};
+        let replacedExpression;
+        if (fieldIds.size) {
+            fieldToValueMap = getFieldValues(fieldIds, encounter);
+        }
+        if (Object.keys(fieldToValueMap).length) {
+            replacedExpression = expression.replace(/(\w+)/g, (match)=>{
+                return Object.prototype.hasOwnProperty.call(fieldToValueMap, match) ? fieldToValueMap[match] : match;
+            });
+        } else {
+            replacedExpression = expression;
+        }
+        return eval(replacedExpression);
+    } catch (error) {
+        throw new Error('Error evaluating expression');
+    }
+}
+function getFieldValues(fieldIds, encounter) {
+    const result = {};
+    fieldIds.forEach((fieldId)=>{
+        let value = encounter.obs?.find((item)=>item.formFieldPath.includes(fieldId))?.value;
+        if (typeof value === 'object') {
+            value = value.uuid;
+        }
+        if (value) {
+            value = formatValue(value);
+        }
+        result[fieldId] = value;
+    });
+    return result;
+}
+//This function wraps string values in single quotes which Javascript will evaluate
+function formatValue(value) {
+    if (typeof value === 'string') {
+        if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+            return value;
+        } else {
+            return `'${value}'`;
+        }
+    }
+    return value;
+}

package/dist/utils/test-utils.js

@@ -0,0 +1,66 @@
+export async function findNumberInput(screen, name) {
+    return await screen.findByRole('spinbutton', {
+        name
+    });
+}
+export async function findTextOrDateInput(screen, name) {
+    return await screen.findByRole('textbox', {
+        name
+    });
+}
+export async function findRadioGroupInput(screen, name) {
+    return await screen.findByRole('group', {
+        name
+    });
+}
+export async function findRadioGroupMember(screen, name) {
+    return await screen.findByRole('radio', {
+        name
+    });
+}
+export async function findCheckboxGroup(screen, name) {
+    return await screen.findByRole('group', {
+        name: new RegExp(name, 'i')
+    });
+}
+export async function findCheckboxSearchable(screen, nameSubstring) {
+    return await screen.findByRole('combobox', {
+        name: new RegExp(nameSubstring, 'i')
+    });
+}
+export async function findSelectInput(screen, name) {
+    return await screen.findByRole('combobox', {
+        name
+    });
+}
+export async function findAllRadioGroupInputs(screen, name) {
+    return await screen.queryAllByRole('group', {
+        name
+    });
+}
+export async function findAllRadioGroupMembers(screen, name) {
+    return await screen.queryAllByRole('radio', {
+        name
+    });
+}
+export async function findAllTextOrDateInputs(screen, name) {
+    return await screen.queryAllByRole('textbox', {
+        name
+    });
+}
+const fieldTypeToGetterMap = {
+    text: findTextOrDateInput,
+    date: findTextOrDateInput,
+    number: findNumberInput,
+    radio: findRadioGroupInput,
+    'radio-group': findRadioGroupInput,
+    'radio-item': findRadioGroupMember,
+    textarea: findTextOrDateInput,
+    checkbox: findCheckboxGroup,
+    'checkbox-searchable': findCheckboxSearchable,
+    select: findSelectInput
+};
+export async function assertFormHasAllFields(screen, fields) {
+    const fieldsInDom = await Promise.all(fields.map(({ fieldName, fieldType })=>fieldTypeToGetterMap[fieldType](screen, fieldName)));
+    await Promise.all(fieldsInDom.map((field)=>expect(field).toBeInTheDocument()));
+}

package/dist/utils/zscore-service.d.ts

@@ -0,0 +1,6 @@
+export declare function getZRefByGenderAndAge(gender: any, birthDate: any, refdate: any): {
+    weightForHeightRef: any;
+    heightForAgeRef: any;
+    bmiForAgeRef: any;
+};
+//# sourceMappingURL=zscore-service.d.ts.map

package/dist/utils/zscore-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zscore-service.d.ts","sourceRoot":"","sources":["../../src/utils/zscore-service.ts"],"names":[],"mappings":"AAWA,wBAAgB,qBAAqB,CAAC,MAAM,KAAA,EAAE,SAAS,KAAA,EAAE,OAAO,KAAA;;;;EAgC/D"}

package/dist/utils/zscore-service.js

@@ -0,0 +1,54 @@
+import filter from "lodash/filter";
+import bfaMale5Above from "../zscore/bfa_boys_5_above.json";
+import wflMaleBelow5 from "../zscore/wfl_boys_below5.json";
+import hfaMale5Above from "../zscore/hfa_boys_5_above.json";
+import hfaMaleBelow5 from "../zscore/hfa_boys_below5.json";
+import bfaFemale5Above from "../zscore/bfa_girls_5_above.json";
+import wflFemaleBelow5 from "../zscore/wfl_girls_below5.json";
+import hfaFemale5Above from "../zscore/hfa_girls_5_above.json";
+import hfaFemaleBelow5 from "../zscore/hfa_girls_below5.json";
+import dayjs from "dayjs";
+export function getZRefByGenderAndAge(gender, birthDate, refdate) {
+    const scoreRefModel = {
+        weightForHeightRef: null,
+        heightForAgeRef: null,
+        bmiForAgeRef: null
+    };
+    const age = getAge(birthDate, refdate, 'years');
+    const ageInMonths = getAge(birthDate, refdate, 'months');
+    const ageInDays = getAge(birthDate, refdate, 'days');
+    if (gender === 'F') {
+        if (age < 5) {
+            scoreRefModel.weightForHeightRef = wflFemaleBelow5;
+            scoreRefModel.heightForAgeRef = getScoreReference(hfaFemaleBelow5, 'Day', ageInDays);
+        }
+        if (age >= 5 && age < 18) {
+            scoreRefModel.bmiForAgeRef = getScoreReference(bfaFemale5Above, 'Month', ageInMonths);
+            scoreRefModel.heightForAgeRef = getScoreReference(hfaFemale5Above, 'Month', ageInMonths);
+        }
+    }
+    if (gender === 'M') {
+        if (age < 5) {
+            scoreRefModel.weightForHeightRef = wflMaleBelow5;
+            scoreRefModel.heightForAgeRef = getScoreReference(hfaMaleBelow5, 'Day', ageInDays);
+        }
+        if (age >= 5 && age < 18) {
+            scoreRefModel.bmiForAgeRef = getScoreReference(bfaMale5Above, 'Month', ageInMonths);
+            scoreRefModel.heightForAgeRef = getScoreReference(hfaMale5Above, 'Month', ageInMonths);
+        }
+    }
+    return scoreRefModel;
+}
+function getScoreReference(refData, searchKey, searchValue) {
+    return filter(refData, (refObject)=>{
+        return refObject[searchKey] === searchValue;
+    });
+}
+function getAge(birthdate, refDate, ageIn) {
+    if (birthdate && refDate && ageIn) {
+        const todayMoment = dayjs(refDate);
+        const birthDateMoment = dayjs(birthdate);
+        return todayMoment.diff(birthDateMoment, ageIn);
+    }
+    return null;
+}

package/dist/validators/conditional-answered-validator.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValidator } from '../types';
+export declare const conditionalAnsweredValidator: FormFieldValidator;
+//# sourceMappingURL=conditional-answered-validator.d.ts.map

package/dist/validators/conditional-answered-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-answered-validator.d.ts","sourceRoot":"","sources":["../../src/validators/conditional-answered-validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAEnE,eAAO,MAAM,4BAA4B,EAAE,kBAa1C,CAAC"}

package/dist/validators/conditional-answered-validator.js

@@ -0,0 +1,18 @@
+import { isEmpty } from "./form-validator.js";
+export const conditionalAnsweredValidator = {
+    validate: function(field, value, config) {
+        const { referenceQuestionId, referenceQuestionAnswers, values, formFields, message } = config;
+        const referencedField = formFields.find((field)=>field.id === referenceQuestionId);
+        const referencedFieldValue = values[referencedField.id];
+        if (!isEmpty(value) && !referenceQuestionAnswers.includes(referencedFieldValue)) {
+            return [
+                {
+                    resultType: 'error',
+                    errCode: 'invalid.valueSelected',
+                    message: message
+                }
+            ];
+        }
+        return [];
+    }
+};

package/dist/validators/conditional-answered-validator.test.js

@@ -0,0 +1,63 @@
+import { conditionalAnsweredValidator } from "./conditional-answered-validator.js";
+import { isEmpty } from "./form-validator.js";
+jest.mock('../validators/form-validator', ()=>({
+        isEmpty: jest.fn()
+    }));
+describe('conditionalAnsweredValidator', ()=>{
+    let field;
+    let value;
+    let config;
+    beforeEach(()=>{
+        field = {
+            label: 'Test Field',
+            type: 'obs',
+            questionOptions: {
+                rendering: 'repeating',
+                concept: 'j8b6705b-b6d8-4eju-8f37-0b14f5347569'
+            },
+            id: 'testFieldId'
+        };
+        config = {
+            referenceQuestionId: 'referenceQuestionId',
+            referenceQuestionAnswers: [
+                'answer1',
+                'answer2'
+            ],
+            values: {
+                referenceQuestionId: 'answer1'
+            },
+            formFields: [
+                {
+                    id: 'referenceQuestionId'
+                }
+            ],
+            message: 'Invalid value selected'
+        };
+    });
+    it('should return no error if value is empty', ()=>{
+        isEmpty.mockReturnValue(true);
+        value = '';
+        const result = conditionalAnsweredValidator.validate(field, value, config);
+        expect(result).toEqual([]);
+    });
+    it('should return no error if value is not empty and reference question answer is included', ()=>{
+        isEmpty.mockReturnValue(false);
+        value = 'some value';
+        config.values.referenceQuestionId = 'answer1';
+        const result = conditionalAnsweredValidator.validate(field, value, config);
+        expect(result).toEqual([]);
+    });
+    it('should return an error if value is not empty and reference question answer is not included', ()=>{
+        isEmpty.mockReturnValue(false);
+        value = 'some value';
+        config.values.referenceQuestionId = 'answer3';
+        const result = conditionalAnsweredValidator.validate(field, value, config);
+        expect(result).toEqual([
+            {
+                resultType: 'error',
+                errCode: 'invalid.valueSelected',
+                message: 'Invalid value selected'
+            }
+        ]);
+    });
+});

package/dist/validators/date-validator.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValidator } from '../types';
+export declare const DateValidator: FormFieldValidator;
+//# sourceMappingURL=date-validator.d.ts.map

package/dist/validators/date-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-validator.d.ts","sourceRoot":"","sources":["../../src/validators/date-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAInE,eAAO,MAAM,aAAa,EAAE,kBAc3B,CAAC"}

package/dist/validators/date-validator.js

@@ -0,0 +1,21 @@
+import { isTrue } from "../utils/boolean-utils.js";
+import { FieldValidator } from "./form-validator.js";
+export const DateValidator = {
+    validate: (field, value, config)=>{
+        const now = new Date();
+        const errors = !value ? FieldValidator.validate(field, value) : [];
+        if (errors.length) {
+            return errors;
+        }
+        if (value && !isTrue(config?.allowFutureDates)) {
+            return value.getTime && value.getTime() > now.getTime() ? [
+                {
+                    resultType: 'error',
+                    errCode: 'value.invalid',
+                    message: 'Future dates not allowed'
+                }
+            ] : [];
+        }
+        return [];
+    }
+};

package/dist/validators/date-validator.test.js

@@ -0,0 +1,53 @@
+import { DateValidator } from "./date-validator.js";
+describe('DateValidator - validate', ()=>{
+    const field = {
+        label: 'HTS Date',
+        type: 'obs',
+        questionOptions: {
+            rendering: 'date',
+            concept: 'j8b6705b-b6d8-4eju-8f37-0b14f5347569'
+        },
+        isRequired: true,
+        required: true,
+        validators: [
+            {
+                type: 'date',
+                allowFutureDates: 'false'
+            }
+        ],
+        meta: {},
+        id: 'hts-date'
+    };
+    it('should reject if an empty date is provided for a required field', ()=>{
+        // setup and replay
+        const errors = DateValidator.validate(field, null, field.validators[0]);
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'field.required',
+                message: 'Field is mandatory',
+                resultType: 'error'
+            }
+        ]);
+    });
+    it('should by default reject future dates', ()=>{
+        // setup and replay
+        const errors = DateValidator.validate(field, new Date('December 17, 2032 03:24:00'), null);
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'value.invalid',
+                message: 'Future dates not allowed',
+                resultType: 'error'
+            }
+        ]);
+    });
+    it('should accept future dates for fields supporting them', ()=>{
+        // setup and replay
+        const errors = DateValidator.validate(field, new Date('December 17, 2032 03:24:00'), {
+            allowFutureDates: true
+        });
+        // verify
+        expect(errors).toEqual([]);
+    });
+});

package/dist/validators/default-value-validator.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValidator } from '../types';
+export declare const DefaultValueValidator: FormFieldValidator;
+//# sourceMappingURL=default-value-validator.d.ts.map

package/dist/validators/default-value-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-value-validator.d.ts","sourceRoot":"","sources":["../../src/validators/default-value-validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAInE,eAAO,MAAM,qBAAqB,EAAE,kBA8BnC,CAAC"}

package/dist/validators/default-value-validator.js

@@ -0,0 +1,46 @@
+import dayjs from "dayjs";
+import { codedTypes } from "../constants.js";
+import { isEmpty } from "./form-validator.js";
+export const DefaultValueValidator = {
+    validate: (field, value)=>{
+        if (!isEmpty(value) && codedTypes.includes(field.questionOptions.rendering)) {
+            const valuesArray = Array.isArray(value) ? value : [
+                value
+            ];
+            // check whether value exists in answers
+            if (!valuesArray.every((val)=>field.questionOptions.answers?.find((answer)=>answer.concept === val || answer.value === val))) {
+                return [
+                    {
+                        resultType: 'error',
+                        errCode: 'invalid.defaultValue',
+                        message: 'Value not found in coded answers list'
+                    }
+                ];
+            }
+        }
+        if (!isEmpty(value) && field.questionOptions.rendering == 'date') {
+            // Check if value is a valid date value
+            if (!dayjs(value).isValid()) {
+                return [
+                    {
+                        resultType: 'error',
+                        errCode: 'invalid.defaultValue',
+                        message: `Invalid date value: '${value}'`
+                    }
+                ];
+            }
+        }
+        if (!isEmpty(value) && field.questionOptions.rendering == 'number') {
+            if (isNaN(value)) {
+                return [
+                    {
+                        resultType: 'error',
+                        errCode: 'invalid.defaultValue',
+                        message: `Invalid numerical  value: '${value}'`
+                    }
+                ];
+            }
+        }
+        return [];
+    }
+};

package/dist/validators/default-value-validator.test.js

@@ -0,0 +1,95 @@
+import { DefaultValueValidator } from "./default-value-validator.js";
+describe('DefaultValueValidator - validate', ()=>{
+    // setup
+    const codedField = {
+        label: 'Past enrolled patient programs',
+        type: 'obs',
+        questionOptions: {
+            rendering: 'checkbox',
+            concept: '3hbkj9-b6d8-4eju-8f37-0b14f5347jv9',
+            answers: [
+                {
+                    label: 'Oncology Screening and Diagnosis Program',
+                    concept: '105e7ad6-c1fd-11eb-8529-0242ac130ju9'
+                },
+                {
+                    label: 'Fight Malaria Initiative',
+                    concept: '305e7ad6-c1fd-11eb-8529-0242ac130003'
+                }
+            ]
+        },
+        id: 'past-patient-programs'
+    };
+    const dateField = {
+        label: 'HTS Date',
+        type: 'obs',
+        questionOptions: {
+            rendering: 'date',
+            concept: 'j8b6705b-b6d8-4eju-8f37-0b14f5347569'
+        },
+        id: 'hts-date'
+    };
+    const numericField = {
+        label: 'Temperature',
+        type: 'obs',
+        questionOptions: {
+            rendering: 'number',
+            concept: '2c43u05b-b6d8-4eju-8f37-0b14f5347560'
+        },
+        id: 'temperature'
+    };
+    it('should accept valid values for coded types', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(codedField, '105e7ad6-c1fd-11eb-8529-0242ac130ju9');
+        // verify
+        expect(errors).toEqual([]);
+    });
+    it('should reject invalid values for coded types', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(codedField, 'some none existing value');
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'invalid.defaultValue',
+                message: 'Value not found in coded answers list',
+                resultType: 'error'
+            }
+        ]);
+    });
+    it('should accept valid date values', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(dateField, '2020-01-20');
+        // verify
+        expect(errors).toEqual([]);
+    });
+    it('should reject invalid date values', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(dateField, 'test date');
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'invalid.defaultValue',
+                message: `Invalid date value: 'test date'`,
+                resultType: 'error'
+            }
+        ]);
+    });
+    it('should accept valid numeric values', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(numericField, '500.5');
+        // verify
+        expect(errors).toEqual([]);
+    });
+    it('should reject invalid numeric values', ()=>{
+        // setup and replay
+        const errors = DefaultValueValidator.validate(numericField, '500.5hds');
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'invalid.defaultValue',
+                message: `Invalid numerical  value: '500.5hds'`,
+                resultType: 'error'
+            }
+        ]);
+    });
+});

package/dist/validators/form-validator.d.ts

@@ -0,0 +1,9 @@
+import { type FormFieldValidator } from '../types';
+export declare const fieldRequiredErrCode = "field.required";
+export declare const fieldOutOfBoundErrCode = "field.outOfBound";
+export declare const FieldValidator: FormFieldValidator;
+export declare function numberInputRangeValidator(min: number, max: number, inputValue: number): any[] | [{}];
+export declare function isEmpty(value: any): boolean;
+export declare function textInputLengthValidator(minLength: string, maxLength: string, inputLength: number): any[] | [{}];
+export declare function addError(errorCode: string, message: string): [{}];
+//# sourceMappingURL=form-validator.d.ts.map

package/dist/validators/form-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-validator.d.ts","sourceRoot":"","sources":["../../src/validators/form-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AACnE,eAAO,MAAM,oBAAoB,mBAAmB,CAAC;AACrD,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AAEzD,eAAO,MAAM,cAAc,EAAE,kBAgC5B,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,gBAUrF;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAW3C;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAqBjG;AAED,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,EAAE,CAAC,CAQjE"}

package/dist/validators/form-validator.js

@@ -0,0 +1,82 @@
+export const fieldRequiredErrCode = 'field.required';
+export const fieldOutOfBoundErrCode = 'field.outOfBound';
+export const FieldValidator = {
+    validate: (field, value)=>{
+        if (field.meta?.submission?.unspecified) {
+            return [];
+        }
+        if (isEmpty(value) && field.isRequired) {
+            if (typeof field.required === 'object' && field.required.type === 'conditionalRequired' && field.isRequired) {
+                return addError(fieldRequiredErrCode, field.required.message ?? 'Field is mandatory');
+            } else if (field.isRequired) {
+                return addError(fieldRequiredErrCode, 'Field is mandatory');
+            }
+        }
+        if (field.questionOptions.rendering === 'text') {
+            const minLength = field.questionOptions.minLength;
+            const maxLength = field.questionOptions.maxLength;
+            return textInputLengthValidator(minLength, maxLength, value?.length) ?? [];
+        }
+        if (field.questionOptions.rendering === 'number') {
+            const min = Number(field.questionOptions.min);
+            const max = Number(field.questionOptions.max);
+            const disallowDecimals = field.questionOptions.disallowDecimals || field.meta?.concept?.allowDecimal;
+            if (isEmpty(value)) return [];
+            if (disallowDecimals && !Number.isInteger(value)) {
+                return addError(fieldOutOfBoundErrCode, 'Decimal values are not allowed for this field');
+            }
+            if (!Number.isNaN(min) || !Number.isNaN(max)) {
+                return numberInputRangeValidator(min, max, value);
+            }
+        }
+        return [];
+    }
+};
+export function numberInputRangeValidator(min, max, inputValue) {
+    if (!Number.isNaN(min) && inputValue < min) {
+        return addError(fieldOutOfBoundErrCode, `Value must be greater than ${min}`);
+    }
+    if (!Number.isNaN(max) && inputValue > max) {
+        return addError(fieldOutOfBoundErrCode, `Value must be lower than ${max}`);
+    }
+    return [];
+}
+export function isEmpty(value) {
+    if (value === undefined || value === null || value === '') {
+        return true;
+    }
+    if (typeof value == 'string' && !value?.trim()) {
+        return true;
+    }
+    if (Array.isArray(value) && !value.length) {
+        return true;
+    }
+    return false;
+}
+export function textInputLengthValidator(minLength, maxLength, inputLength) {
+    const minLen = Number(minLength);
+    const maxLen = Number(maxLength);
+    if (typeof inputLength === 'number' && !Number.isNaN(inputLength)) {
+        if (minLen && maxLen && inputLength >= minLen && inputLength <= maxLen) {
+            return [];
+        }
+        if (minLen && inputLength < minLen) {
+            return addError(fieldOutOfBoundErrCode, `Length should be at least ${minLen} characters`);
+        }
+        if (maxLen && inputLength > maxLen) {
+            return addError(fieldOutOfBoundErrCode, `Length should not exceed ${maxLen} characters`);
+        }
+        if (maxLen && minLen && inputLength < minLen && inputLength > maxLen) {
+            return addError(fieldOutOfBoundErrCode, `Length should be between ${minLen} and ${maxLen} characters`);
+        }
+    }
+}
+export function addError(errorCode, message) {
+    return [
+        {
+            resultType: 'error',
+            errCode: errorCode,
+            message: message
+        }
+    ];
+}