@openmrs/esm-form-engine-lib 2.1.0-pre.1362

package/src/utils/test-utils.ts

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

package/src/utils/zscore-service.ts

@@ -0,0 +1,59 @@
+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): any {
+  return filter(refData, (refObject) => {
+    return refObject[searchKey] === searchValue;
+  });
+}
+
+function getAge(birthdate, refDate, ageIn) {
+  if (birthdate && refDate && ageIn) {
+    const todayMoment: any = dayjs(refDate);
+    const birthDateMoment: any = dayjs(birthdate);
+    return todayMoment.diff(birthDateMoment, ageIn);
+  }
+  return null;
+}

package/src/validators/conditional-answered-validator.test.ts

@@ -0,0 +1,61 @@
+import { conditionalAnsweredValidator } from './conditional-answered-validator';
+import { isEmpty } from '../validators/form-validator';
+import { type FormField, FormFieldValidator } from '../types';
+
+jest.mock('../validators/form-validator', () => ({
+  isEmpty: jest.fn(),
+}));
+
+describe('conditionalAnsweredValidator', () => {
+  let field: FormField;
+  let value: unknown;
+  let config: any;
+
+  beforeEach(() => {
+    field = {
+      label: 'Test Field',
+      type: 'obs',
+      questionOptions: { rendering: 'repeating', concept: 'j8b6705b-b6d8-4eju-8f37-0b14f5347569' },
+      id: 'testFieldId',
+    } as FormField;
+
+    config = {
+      referenceQuestionId: 'referenceQuestionId',
+      referenceQuestionAnswers: ['answer1', 'answer2'],
+      values: { referenceQuestionId: 'answer1' },
+      fields: [{ id: 'referenceQuestionId' }],
+      message: 'Invalid value selected',
+    };
+  });
+
+  it('should return no error if value is empty', () => {
+    (isEmpty as jest.Mock).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 as jest.Mock).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 as jest.Mock).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/src/validators/conditional-answered-validator.ts

@@ -0,0 +1,17 @@
+import { isEmpty } from '../validators/form-validator';
+import { type FormFieldValidator, type FormField } from '../types';
+
+export const conditionalAnsweredValidator: FormFieldValidator = {
+  validate: function (field: FormField, value: unknown, config: Record<string, any>) {
+    const { referenceQuestionId, referenceQuestionAnswers, values, fields, message } = config;
+
+    const referencedField = fields.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/src/validators/date-validator.test.ts

@@ -0,0 +1,46 @@
+import { type FormField } from '../types';
+import { DateValidator } from './date-validator';
+
+describe('DateValidator - validate', () => {
+  const field: FormField = {
+    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/src/validators/date-validator.ts

@@ -0,0 +1,19 @@
+import { type FormFieldValidator, type FormField } from '../types';
+import { isTrue } from '../utils/boolean-utils';
+import { FieldValidator } from './form-validator';
+
+export const DateValidator: FormFieldValidator = {
+  validate: (field: FormField, value: Date, config: any) => {
+    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/src/validators/default-value-validator.test.ts

@@ -0,0 +1,90 @@
+import { type FormField } from '../types';
+import { DefaultValueValidator } from './default-value-validator';
+
+describe('DefaultValueValidator - validate', () => {
+  // setup
+  const codedField: FormField = {
+    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: FormField = {
+    label: 'HTS Date',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'date',
+      concept: 'j8b6705b-b6d8-4eju-8f37-0b14f5347569',
+    },
+    id: 'hts-date',
+  };
+  const numericField: FormField = {
+    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/src/validators/default-value-validator.ts

@@ -0,0 +1,36 @@
+import dayjs from 'dayjs';
+import { type FormFieldValidator, type FormField } from '../types';
+import { codedTypes } from '../constants';
+import { isEmpty } from './form-validator';
+
+export const DefaultValueValidator: FormFieldValidator = {
+  validate: (field: FormField, value: any) => {
+    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: string) =>
+          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/src/validators/form-validator.test.ts

@@ -0,0 +1,188 @@
+import { type FormField } from '../types';
+import { FieldValidator } from './form-validator';
+
+
+describe('FieldValidator - validate', () => {
+  const numberInputField: FormField = {
+    label: 'A Question of type obs that renders a Number input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'number',
+      concept: 'a-system-defined-concept-uuid',
+      min: '5',
+      max: '10',
+    },
+    meta: {},
+    id: 'sampleNumberQuestion',
+  };
+
+  const numberWithDecimalsInputField: FormField = {
+    label: 'A Question of type obs that renders a Number input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'number',
+      concept: 'a-system-defined-concept-uuid',
+      disallowDecimals: true,
+      min: '5.0',
+      max: '10.0',
+    },
+    id: 'sampleNumberWithDecimalsQuestion',
+  };
+
+  const textInputField: FormField = {
+    label: 'A Question of type obs that renders a Text input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'text',
+      concept: 'a-system-defined-concept-uuid',
+      minLength: '5',
+      maxLength: '10',
+    },
+    meta: {},
+    id: 'sampleTextQuestion',
+  };
+
+  const textInputFieldWithoutValidation: FormField = {
+    label: 'A Question of type obs that renders a Text input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'text',
+      concept: 'a-system-defined-concept-uuid',
+    },
+    meta: {},
+    id: 'sampleTextQuestion',
+  };
+
+  const textInputFieldWithMinValidation: FormField = {
+    label: 'A Question of type obs that renders a Text input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'text',
+      concept: 'a-system-defined-concept-uuid',
+      minLength: '5',
+    },
+    meta: {},
+    id: 'sampleTextQuestion',
+  };
+
+  const textInputFieldWithMaxValidation: FormField = {
+    label: 'A Question of type obs that renders a Text input',
+    type: 'obs',
+    questionOptions: {
+      rendering: 'text',
+      concept: 'a-system-defined-concept-uuid',
+      maxLength: '10',
+    },
+    meta: {},
+    id: 'sampleTextQuestion',
+  };
+
+  it('should fail on wrong max length only for inputText', () => {
+    const validationErrors = FieldValidator.validate(textInputFieldWithMaxValidation, 'super long text to test', null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Length should not exceed ${textInputField.questionOptions.maxLength} characters`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should fail on wrong min length only for inputText', () => {
+    const validationErrors = FieldValidator.validate(textInputFieldWithMinValidation, 'sup', null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Length should be at least ${textInputField.questionOptions.minLength} characters`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should not fail if min and max is not defined for inputText', () => {
+    const validationErrors = FieldValidator.validate(
+      textInputFieldWithoutValidation,
+      'super text super text super text',
+      null
+    );
+
+    expect(validationErrors).toEqual([]);
+  });
+
+  it('should fail for text length greater than the max defined length', () => {
+    const validationErrors = FieldValidator.validate(textInputField, 'super text super text super text', null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Length should not exceed ${textInputField.questionOptions.maxLength} characters`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should fail for text length lesser than the min defined length', () => {
+    const validationErrors = FieldValidator.validate(textInputField, 'text', null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Length should be at least ${textInputField.questionOptions.minLength} characters`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should accept value with length within the defined range', () => {
+    const validationErrors = FieldValidator.validate(textInputField, 'qwertyu', null);
+    expect(validationErrors).toEqual([]);
+  });
+
+  it('should accept value with length equal to minLength', () => {
+    const validationErrors = FieldValidator.validate(textInputField, 'qwert', null);
+    expect(validationErrors).toEqual([]);
+  });
+
+  it('should accept value with length equal to maxLength', () => {
+    const validationErrors = FieldValidator.validate(textInputField, 'qwertyuiop', null);
+    expect(validationErrors).toEqual([]);
+  });
+
+  // Number Input Validator Tests
+  it('should fail for number lesser than the defined min allowed', () => {
+    const validationErrors = FieldValidator.validate(numberInputField, 3, null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Value must be greater than ${numberInputField.questionOptions.min}`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should fail for numbers greater than the defined max allowed', () => {
+    const validationErrors = FieldValidator.validate(numberInputField, 100, null);
+
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: `Value must be lower than ${numberInputField.questionOptions.max}`,
+        resultType: 'error',
+      },
+    ]);
+  });
+
+  it('should fail for numbers with decimals', () => {
+    const validationErrors = FieldValidator.validate(numberWithDecimalsInputField, 8.5, null);
+    expect(validationErrors).toEqual([
+      {
+        errCode: 'field.outOfBound',
+        message: 'Decimal values are not allowed for this field',
+        resultType: 'error',
+      },
+    ]);
+  });
+});

package/src/validators/form-validator.ts

@@ -0,0 +1,95 @@
+import { type FormFieldValidator, type FormField } from '../types';
+export const fieldRequiredErrCode = 'field.required';
+export const fieldOutOfBoundErrCode = 'field.outOfBound';
+
+export const FieldValidator: FormFieldValidator = {
+  validate: (field: FormField, value: any) => {
+    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: number, max: number, inputValue: number) {
+  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: any): boolean {
+  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: string, maxLength: string, inputLength: number) {
+  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: string, message: string): [{}] {
+  return [
+    {
+      resultType: 'error',
+      errCode: errorCode,
+      message: message,
+    },
+  ];
+}