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

package/src/validators/js-expression-validator.test.ts

@@ -0,0 +1,118 @@
+import dayjs from 'dayjs';
+import { type FormField } from '../types';
+import { type ExpressionContext } from '../utils/expression-runner';
+import { testFields } from '../utils/expression-runner.test';
+import { ExpressionValidator } from './js-expression-validator';
+
+describe('ExpressionValidator - validate', () => {
+  // base setup
+  const allFields = JSON.parse(JSON.stringify(testFields));
+  let values = {
+    linkedToCare: '',
+    patientIdentificationNumber: '',
+    htsProviderRemarks: '',
+    referredToPreventionServices: [],
+    bodyTemperature: 0,
+    testDate: null,
+  };
+  const expressionContext: ExpressionContext = { mode: 'enter', patient: {} };
+
+  it('should evaluate js expressions', () => {
+    // setup
+    const field = allFields.find((f) => f.id == 'htsProviderRemarks');
+    const failsWhenExpression = '!isEmpty(myValue) && isEmpty(`referredToPreventionServices`)';
+
+    // replay
+    let errors = ExpressionValidator.validate(field, 'Remarks..', {
+      failsWhenExpression,
+      expressionContext,
+      values,
+      message: 'Atleast one type of Prevention Services must be selected',
+      fields: allFields,
+    });
+
+    // verify
+    expect(errors).toEqual([
+      {
+        errCode: 'value.invalid',
+        message: 'Atleast one type of Prevention Services must be selected',
+        resultType: 'error',
+      },
+    ]);
+
+    // provide some value(s) for Prevention Services
+    values['referredToPreventionServices'] = ['1691AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'];
+
+    // replay
+    errors = ExpressionValidator.validate(field, 'Remarks..', {
+      failsWhenExpression,
+      expressionContext,
+      values,
+      message: 'Atleast one type of Prevention Services must be selected',
+      fields: allFields,
+    });
+
+    // verify
+    expect(errors).toEqual([]);
+  });
+
+  fit('should fail if date value is not within the configured bounds', () => {
+    // setup
+    const dateField: FormField = {
+      label: 'Test Date',
+      type: 'obs',
+      questionOptions: {
+        rendering: 'date',
+        concept: '637d1e25-evav-481c-aabc-01fw1c6cdefo',
+      },
+      validators: [
+        {
+          type: 'js_expression',
+          failsWhenExpression: "isDateBefore(myValue, '2020-12-01') || myValue > today()",
+          message: "Value cannot be before '2020-12-01' or after today",
+        },
+      ],
+      id: 'testDate',
+    };
+    allFields.push(dateField);
+
+    // replay
+    let errors = ExpressionValidator.validate(dateField, dayjs('2020-11-13', 'YYYY-MM-DD', true).toDate(), {
+      ...dateField.validators[0],
+      expressionContext,
+      values,
+      fields: allFields,
+    });
+
+    // verify
+    expect(errors).toEqual([
+      { errCode: 'value.invalid', message: "Value cannot be before '2020-12-01' or after today", resultType: 'error' },
+    ]);
+
+    // set & replay
+    const futureDate = new Date();
+    futureDate.setDate(futureDate.getDate() + 10);
+    errors = ExpressionValidator.validate(dateField, futureDate, {
+      ...dateField.validators[0],
+      expressionContext,
+      values,
+      fields: allFields,
+    });
+
+    // verify
+    expect(errors).toEqual([
+      { errCode: 'value.invalid', message: "Value cannot be before '2020-12-01' or after today", resultType: 'error' },
+    ]);
+
+    // replay
+    errors = ExpressionValidator.validate(dateField, dayjs('2021-11-12', 'YYYY-MM-DD', true).toDate(), {
+      ...dateField.validators[0],
+      expressionContext,
+      values,
+      fields: allFields,
+    });
+
+    // verify
+    expect(errors).toEqual([]);
+  });
+});

package/src/validators/js-expression-validator.ts

@@ -0,0 +1,44 @@
+import { type FormFieldValidator, type FormField } from '../types';
+import { evaluateExpression, type ExpressionContext } from '../utils/expression-runner';
+
+interface ExpressionValidatorConfig {
+  failsWhenExpression?: string;
+  warnsWhenExpression?: string;
+  message: string;
+  fields: FormField[];
+  expressionContext: ExpressionContext;
+  values: Record<string, any>;
+}
+
+export const ExpressionValidator: FormFieldValidator = {
+  validate: function (field: FormField, value: any, config: ExpressionValidatorConfig) {
+    const INVALID_VALUE_ERR_CODE = 'value.invalid';
+    const INVALID_VALUE_ERR_MESSAGE = 'Invalid value';
+    const FIELD_HAS_WARNINGS_MESSAGE = 'Field has warnings';
+    config.expressionContext.myValue = value;
+    return Object.keys(config)
+      .filter((key) => key === 'failsWhenExpression' || key === 'warnsWhenExpression')
+      .flatMap((key) => {
+        const isErrorValidator = key === 'failsWhenExpression';
+        return evaluateExpression(
+          config[key],
+          { value: field, type: 'field' },
+          config.fields,
+          { ...config.values, [field.id]: value },
+          config.expressionContext,
+        )
+          ? [
+              {
+                resultType: isErrorValidator ? 'error' : 'warning',
+                errCode: isErrorValidator ? INVALID_VALUE_ERR_CODE : null,
+                message: config.message
+                  ? config.message
+                  : isErrorValidator
+                  ? INVALID_VALUE_ERR_MESSAGE
+                  : FIELD_HAS_WARNINGS_MESSAGE,
+              },
+            ]
+          : [];
+      });
+  },
+};

package/src/validators/schema.ts

@@ -0,0 +1,34 @@
+// import { z, type ZodTypeAny } from 'zod';
+// import { type FormFieldValidator, type FormField, type ValidationResult } from '../types';
+
+// TODOs
+// - add a reactive context to evaluate expressions
+// - figure out how to track errors vs warnings with different severity levels
+// (I will be managing validation manually for now until I figure out the above)
+// export const createValidationSchema = (formFields: FormField[], validators: Record<string, FormFieldValidator>) => {
+//   const schemaShape: Record<string, ZodTypeAny> = {};
+//   formFields.forEach((field) => {
+//     schemaShape[field.id] = zodFieldValidator(field, validators);
+//   });
+//   return z.object(schemaShape);
+// };
+
+// const zodFieldValidator = (field: FormField, validators: Record<string, FormFieldValidator>) => {
+//   return z.any().refine((value) => {
+//     const errorsAndWarnings: ValidationResult[] = [];
+//     try {
+//       field.validators.forEach((validatorConfig) => {
+//         const errorsAndWarnings = validators[validatorConfig.type]?.validate?.(field, value, validatorConfig);
+//         if (errorsAndWarnings?.length) {
+//           errorsAndWarnings.forEach((errorOrWarning) => {
+//             errorsAndWarnings.push(errorOrWarning);
+//           });
+//         }
+//       });
+//       return errorsAndWarnings.length === 0;
+//     } catch (error) {
+//       console.error(error);
+//       return false;
+//     }
+//   });
+// };