@olaboot/esm-form-engine-lib 4.1.0

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

@@ -0,0 +1,158 @@
+import { FieldValidator } from "./form-validator.js";
+describe('FieldValidator - validate', ()=>{
+    const numberInputField = {
+        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 = {
+        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 = {
+        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 = {
+        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 = {
+        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 = {
+        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/dist/validators/js-expression-validator.d.ts

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

package/dist/validators/js-expression-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-expression-validator.d.ts","sourceRoot":"","sources":["../../src/validators/js-expression-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAYnE,eAAO,MAAM,mBAAmB,EAAE,kBA+BjC,CAAC"}

package/dist/validators/js-expression-validator.js

@@ -0,0 +1,25 @@
+import { evaluateExpression } from "../utils/expression-runner.js";
+export const ExpressionValidator = {
+    validate: function(field, value, config) {
+        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.formFields, {
+                ...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/dist/validators/js-expression-validator.test.js

@@ -0,0 +1,115 @@
+import dayjs from "dayjs";
+import { testFields } from "../utils/expression-runner.test.js";
+import { ExpressionValidator } from "./js-expression-validator.js";
+describe('ExpressionValidator - validate', ()=>{
+    // base setup
+    const allFields = JSON.parse(JSON.stringify(testFields));
+    let values = {
+        linkedToCare: '',
+        patientIdentificationNumber: '',
+        htsProviderRemarks: '',
+        referredToPreventionServices: [],
+        bodyTemperature: 0,
+        testDate: null
+    };
+    const 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: 'At least one type of Prevention Services must be selected',
+            formFields: allFields
+        });
+        // verify
+        expect(errors).toEqual([
+            {
+                errCode: 'value.invalid',
+                message: 'At least 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',
+            formFields: allFields
+        });
+        // verify
+        expect(errors).toEqual([]);
+    });
+    it('should fail if date value is not within the configured bounds', ()=>{
+        // setup
+        const dateField = {
+            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,
+            formFields: 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,
+            formFields: 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,
+            formFields: allFields
+        });
+        // verify
+        expect(errors).toEqual([]);
+    });
+});

package/dist/validators/schema.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=schema.d.ts.map

package/dist/validators/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/validators/schema.ts"],"names":[],"mappings":""}

package/dist/validators/schema.js

@@ -0,0 +1,32 @@
+// 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;
+//     }
+//   });
+// };